diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..783acd69
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    groups:
+      github-action-deps:
+        applies-to: "version-updates"
+        patterns: ["*"]
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 00000000..8c5b13ed
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,44 @@
+name: CI
+on:
+  create: # when tags are created
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+jobs:
+  Build_Windows:
+    runs-on: windows-latest
+    steps:
+    - name: Checkout Repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Install .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+
+    - name: Restore dependencies
+      run: dotnet restore src
+
+    - name: Build Project
+      run: dotnet build -c Release --no-restore src
+
+    - name: Build Packages
+      run: dotnet pack src/ImGui.NET -c Release --no-restore --no-build
+
+    - name: List Packages
+      run: ls -l bin\Release\ImGui.NET\
+
+    - name: Validate Generated Code
+      if: false # startsWith(github.ref, 'refs/tags/')
+      shell: bash
+      run: |
+        echo "Running CodeGenerator"
+        bin/Release/CodeGenerator/net8.0/CodeGenerator.exe "src/ImGui.NET/Generated"
+        git status -s | findstr . && echo "ERROR: CodeGenerator is not executed, please execute it." && exit 1 || exit 0
+
+    - name: Publish to nuget.org
+      if: startsWith(github.ref, 'refs/tags/')
+      run: dotnet nuget push bin\Release\ImGui.NET\*.nupkg -s https://api.nuget.org/v3/index.json --api-key ${{secrets.NUGET_KEY}}
diff --git a/.gitignore b/.gitignore
index 93242c60..4f2d501f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -259,4 +259,7 @@ Session.vim
 .idea
 
 # download dir
-deps/
\ No newline at end of file
+deps/
+
+# VS Launch
+launchSettings.json
\ No newline at end of file
diff --git a/NuGet.Config b/NuGet.Config
deleted file mode 100644
index eba6f654..00000000
--- a/NuGet.Config
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSources>
-    <add key="dotnet-myget dotnet-core" value="https://dotnet.myget.org/F/dotnet-core/api/v3/index.json" />
-  </packageSources>
-</configuration>
diff --git a/README.md b/README.md
index beaa7133..79d4441a 100644
--- a/README.md
+++ b/README.md
@@ -2,13 +2,13 @@
 
 This is a .NET wrapper for the immediate mode GUI library, Dear ImGui (https://github.com/ocornut/imgui). ImGui.NET lets you build graphical interfaces using a simple immediate-mode style. ImGui.NET is a .NET Standard library, and can be used on all major .NET runtimes and operating systems.
 
-Included is a basic sample program that shows how to use the library, and renders the UI using [Veldrid](https://github.com/mellinoe/veldrid), a portable graphics library for .NET. By itself, Dear ImGui does not care what technology you use for rendering; it simply outputs textured triangles. Example renderers also exist for MonoGame and OpenTK (OpenGL).
+Included is a basic sample program that shows how to use the library, and renders the UI using [Veldrid](https://github.com/veldrid/veldrid), a portable graphics library for .NET. By itself, Dear ImGui does not care what technology you use for rendering; it simply outputs textured triangles. Example renderers also exist for MonoGame and OpenTK (OpenGL).
 
-This wrapper is built on top of [cimgui](https://github.com/Extrawurst/cimgui), which exposes a plain C API for Dear ImGui. If you are using Windows, OSX, or a mainline Linux distribution, then the ImGui.NET NuGet package comes bundled with a pre-built native library. If you are using another operating system, then you may need to build the native library yourself; see the cimgui repo for build instructions.
+This wrapper is built on top of [cimgui](https://github.com/cimgui/cimgui), which exposes a plain C API for Dear ImGui. If you are using Windows, OSX, or a mainline Linux distribution, then the ImGui.NET NuGet package comes bundled with a pre-built native library. If you are using another operating system, then you may need to build the native library yourself; see the cimgui repo for build instructions.
 
 [![NuGet](https://img.shields.io/nuget/v/ImGui.NET.svg)](https://www.nuget.org/packages/ImGui.NET)
 
-[![Join the chat at https://gitter.im/ImGui-NET/Lobby](https://badges.gitter.im/ImGui-NET/Lobby.svg)](https://gitter.im/ImGui-NET/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+___As of February 2023, I (@mellinoe) am no longer able to publicly share updates to ImGui.NET and related libraries. A big thanks to @zaafar who continues to actively maintain the library and keep it up to date with new versions of native Dear ImGui. Feel free to join the [Discord server](https://discord.gg/s5EvvWJ) for more information about the current status of development.___
 
 # Building
 
@@ -16,7 +16,16 @@ ImGui.NET can be built in Visual Studio or on the command line. The .NET Core SD
 
 # Usage
 
-ImGui.NET currently provides a raw wrapper around the ImGui native API, and also provides a very thin safe, managed API for convenience. It is currently very much like using the native library, which is very simple, flexible, and robust. The easiest way to figure out how to use the library is to read the documentation of imgui itself, mostly in the imgui.cpp, and imgui.h files, as well as the exported functions in cimgui.h. Looking at the sample program code will also give some indication about basic usage.
+ImGui.NET currently provides a raw wrapper around the ImGui native API, and also provides a very thin safe, managed API for convenience. It is currently very much like using the native library, which is very simple, flexible, and robust. The easiest way to figure out how to use the library is to read the documentation of imgui itself, mostly in the imgui.cpp, and imgui.h files, as well as the exported functions in cimgui.h. Looking at the [sample program code](https://github.com/ImGuiNET/ImGui.NET/tree/master/src) will also give some indication about basic usage.
+
+# Debugging native code
+
+ImGui.NET is a wrapper over native code. By default, this native code is packaged and released in an optimized form, making debugging difficult. To obtain a debuggable version of the native code, follow these steps:
+
+1. Clone the [ImGui.NET-nativebuild](https://github.com/ImGuiNET/ImGui.NET-nativebuild) repo, at the tag matching the version of ImGui.NET you are using.
+2. In the ImGui.NET-nativebuild repo, run `build.cmd debug` or `build.sh debug` (depending on your platform).
+3. Copy the produced binaries (cimgui.dll, libcimgui.so, or libcimgui.dylib) into your application.
+4. Run the program under a native debugger, or enable mixed-mode debugging in Visual Studio.
 
 # See Also
 
@@ -29,5 +38,5 @@ https://github.com/ocornut/imgui
 
 See the [official screenshot thread](https://github.com/ocornut/imgui/issues/123) for examples of many different kinds of interfaces created with Dear ImGui.
 
-https://github.com/Extrawurst/cimgui
+https://github.com/cimgui/cimgui
 > This is a thin c-api wrapper for the excellent C++ intermediate gui imgui. This library is intended as a intermediate layer to be able to use imgui from other languages that can interface with C .
diff --git a/deps/cimgui/linux-x64/cimgui.so b/deps/cimgui/linux-x64/cimgui.so
index d87f2da3..8832cb77 100644
Binary files a/deps/cimgui/linux-x64/cimgui.so and b/deps/cimgui/linux-x64/cimgui.so differ
diff --git a/deps/cimgui/osx-x64/cimgui.dylib b/deps/cimgui/osx-x64/cimgui.dylib
deleted file mode 100644
index abea0eb0..00000000
Binary files a/deps/cimgui/osx-x64/cimgui.dylib and /dev/null differ
diff --git a/deps/cimgui/osx/cimgui.dylib b/deps/cimgui/osx/cimgui.dylib
new file mode 100644
index 00000000..bf82e7b3
Binary files /dev/null and b/deps/cimgui/osx/cimgui.dylib differ
diff --git a/deps/cimgui/win-arm64/cimgui.dll b/deps/cimgui/win-arm64/cimgui.dll
new file mode 100644
index 00000000..bd36c84d
Binary files /dev/null and b/deps/cimgui/win-arm64/cimgui.dll differ
diff --git a/deps/cimgui/win-x64/cimgui.dll b/deps/cimgui/win-x64/cimgui.dll
index e50f85b9..7c3c1b80 100644
Binary files a/deps/cimgui/win-x64/cimgui.dll and b/deps/cimgui/win-x64/cimgui.dll differ
diff --git a/deps/cimgui/win-x86/cimgui.dll b/deps/cimgui/win-x86/cimgui.dll
index 691100e0..2456eb7f 100644
Binary files a/deps/cimgui/win-x86/cimgui.dll and b/deps/cimgui/win-x86/cimgui.dll differ
diff --git a/download-native-deps.ps1 b/download-native-deps.ps1
old mode 100644
new mode 100755
index 3adadb2e..d37236f1
--- a/download-native-deps.ps1
+++ b/download-native-deps.ps1
@@ -1,7 +1,13 @@
 param (
+    [Parameter(Mandatory=$false)][string]$repository,
     [Parameter(Mandatory=$true)][string]$tag
 )
 
+if( -not $repository )
+{
+    $repository="https://github.com/mellinoe/imgui.net-nativebuild"
+}
+
 Write-Host Downloading native binaries from GitHub Releases...
 
 if (Test-Path $PSScriptRoot\deps\cimgui\)
@@ -9,15 +15,16 @@ if (Test-Path $PSScriptRoot\deps\cimgui\)
     Remove-Item $PSScriptRoot\deps\cimgui\ -Force -Recurse | Out-Null
 }
 New-Item -ItemType Directory -Force -Path $PSScriptRoot\deps\cimgui\linux-x64 | Out-Null
-New-Item -ItemType Directory -Force -Path $PSScriptRoot\deps\cimgui\osx-x64 | Out-Null
+New-Item -ItemType Directory -Force -Path $PSScriptRoot\deps\cimgui\osx | Out-Null
 New-Item -ItemType Directory -Force -Path $PSScriptRoot\deps\cimgui\win-x86 | Out-Null
 New-Item -ItemType Directory -Force -Path $PSScriptRoot\deps\cimgui\win-x64 | Out-Null
+New-Item -ItemType Directory -Force -Path $PSScriptRoot\deps\cimgui\win-arm64 | Out-Null
 
 [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
 
 $client = New-Object System.Net.WebClient
 $client.DownloadFile(
-    "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$tag/cimgui.win-x86.dll",
+    "$repository/releases/download/$tag/cimgui.win-x86.dll",
     "$PSScriptRoot/deps/cimgui/win-x86/cimgui.dll")
 if( -not $? )
 {
@@ -29,7 +36,7 @@ if( -not $? )
 Write-Host "- cimgui.dll (x86)"
 
 $client.DownloadFile(
-    "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$tag/cimgui.win-x64.dll",
+    "$repository/releases/download/$tag/cimgui.win-x64.dll",
     "$PSScriptRoot/deps/cimgui/win-x64/$configuration/cimgui.dll")
 if( -not $? )
 {
@@ -41,7 +48,19 @@ if( -not $? )
 Write-Host "- cimgui.dll (x64)"
 
 $client.DownloadFile(
-    "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$tag/cimgui.so",
+    "$repository/releases/download/$tag/cimgui.win-arm64.dll",
+    "$PSScriptRoot/deps/cimgui/win-arm64/$configuration/cimgui.dll")
+if( -not $? )
+{
+    $msg = $Error[0].Exception.Message
+    Write-Error "Couldn't download arm64 cimgui.dll. This most likely indicates the Windows native build failed."
+    exit
+}
+
+Write-Host "- cimgui.dll (arm64)"
+
+$client.DownloadFile(
+    "$repository/releases/download/$tag/cimgui.so",
     "$PSScriptRoot/deps/cimgui/linux-x64/cimgui.so")
 if( -not $? )
 {
@@ -53,8 +72,8 @@ if( -not $? )
 Write-Host - cimgui.so
 
 $client.DownloadFile(
-    "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$tag/cimgui.dylib",
-    "$PSScriptRoot/deps/cimgui/osx-x64/cimgui.dylib")
+    "$repository/releases/download/$tag/cimgui.dylib",
+    "$PSScriptRoot/deps/cimgui/osx/cimgui.dylib")
 if( -not $? )
 {
     $msg = $Error[0].Exception.Message
@@ -62,4 +81,28 @@ if( -not $? )
     exit
 }
 
-Write-Host - cimgui.dylib
+Write-Host "- cimgui.dylib"
+
+$client.DownloadFile(
+    "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$tag/definitions.json",
+    "$PSScriptRoot/src/CodeGenerator/definitions/cimgui/definitions.json")
+if( -not $? )
+{
+    $msg = $Error[0].Exception.Message
+    Write-Error "Couldn't download definitions.json."
+    exit
+}
+
+Write-Host - definitions.json
+
+$client.DownloadFile(
+    "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$tag/structs_and_enums.json",
+    "$PSScriptRoot/src/CodeGenerator/definitions/cimgui/structs_and_enums.json")
+if( -not $? )
+{
+    $msg = $Error[0].Exception.Message
+    Write-Error "Couldn't download structs_and_enums.json."
+    exit
+}
+
+Write-Host - structs_and_enums.json
diff --git a/download-native-deps.sh b/download-native-deps.sh
new file mode 100755
index 00000000..38dd1322
--- /dev/null
+++ b/download-native-deps.sh
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+
+if [ $# -eq 0 ]; then
+    echo "Missing first argument. Please provide the tag to download."
+    exit 1
+fi
+
+TAG=$1
+
+SCRIPT_ROOT=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+echo "Script is located in: $SCRIPT_ROOT"
+echo "Using Tag: $TAG"
+
+echo -n "Downloading windows x86 cimgui: "
+curl -sfLo "$SCRIPT_ROOT/deps/cimgui/win-x86/cimgui.dll" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/cimgui.win-x86.dll"
+echo ""
+
+echo -n "Downloading windows x64 cimgui: "
+curl -sfLo "$SCRIPT_ROOT/deps/cimgui/win-x64/cimgui.dll" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/cimgui.win-x64.dll"
+echo ""
+
+echo -n "Downloading windows arm64 cimgui: "
+curl -sfLo "$SCRIPT_ROOT/deps/cimgui/win-arm64/cimgui.dll" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/cimgui.win-arm64.dll"
+echo ""
+
+echo -n "Downloading linux x64 cimgui: "
+curl -sfLo "$SCRIPT_ROOT/deps/cimgui/linux-x64/cimgui.so" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/cimgui.so"
+echo ""
+
+echo -n "Downloading osx universal (x86_64 and arm64) cimgui: "
+curl -sfLo "$SCRIPT_ROOT/deps/cimgui/osx/cimgui.dylib" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/cimgui.dylib"
+echo ""
+
+echo -n "Downloading definitions json file: "
+curl -sfLo "$SCRIPT_ROOT/src/CodeGenerator/definitions/cimgui/definitions.json" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/definitions.json"
+echo ""
+
+echo -n "Downloading structs and enums json file: "
+curl -sfLo "$SCRIPT_ROOT/src/CodeGenerator/definitions/cimgui/structs_and_enums.json" "https://github.com/mellinoe/imgui.net-nativebuild/releases/download/$TAG/structs_and_enums.json"
+echo ""
\ No newline at end of file
diff --git a/src/CodeGenerator/CSharpCodeWriter.cs b/src/CodeGenerator/CSharpCodeWriter.cs
index 045b33c7..c7709639 100644
--- a/src/CodeGenerator/CSharpCodeWriter.cs
+++ b/src/CodeGenerator/CSharpCodeWriter.cs
@@ -47,6 +47,16 @@ private void WriteIndented(string text)
             _sw.WriteLine(text);
         }
 
+        public void WriteRaw(string text)
+        {
+            _sw.WriteLine(text);
+        }
+
+        public void IndentManually()
+        {
+            _indentLevel += 4;
+        }
+
         public void Dispose()
         {
             _sw.Dispose();
diff --git a/src/CodeGenerator/CodeGenerator.csproj b/src/CodeGenerator/CodeGenerator.csproj
index 9f05ccc5..422fcc00 100644
--- a/src/CodeGenerator/CodeGenerator.csproj
+++ b/src/CodeGenerator/CodeGenerator.csproj
@@ -1,17 +1,29 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <Content Include="structs_and_enums.json" CopyToOutputDirectory="PreserveNewest" />
-    <Content Include="definitions.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimgui\structs_and_enums.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimgui\definitions.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimgui\variants.json" CopyToOutputDirectory="PreserveNewest" />
+
+    <Content Include="definitions\cimplot\structs_and_enums.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimplot\definitions.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimplot\variants.json" CopyToOutputDirectory="PreserveNewest" />
+
+    <Content Include="definitions\cimnodes\structs_and_enums.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimnodes\definitions.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimnodes\variants.json" CopyToOutputDirectory="PreserveNewest" />
+
+    <Content Include="definitions\cimguizmo\structs_and_enums.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimguizmo\definitions.json" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="definitions\cimguizmo\variants.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
-
 </Project>
diff --git a/src/CodeGenerator/ImguiDefinitions.cs b/src/CodeGenerator/ImguiDefinitions.cs
new file mode 100644
index 00000000..23edaee5
--- /dev/null
+++ b/src/CodeGenerator/ImguiDefinitions.cs
@@ -0,0 +1,562 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.IO;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Xml.Linq;
+
+namespace CodeGenerator
+{
+    class ImguiDefinitions
+    {
+        public EnumDefinition[] Enums;
+        public TypeDefinition[] Types;
+        public FunctionDefinition[] Functions;
+        public Dictionary<string, MethodVariant> Variants;
+
+        static int GetInt(JToken token, string key)
+        {
+            var v = token[key];
+            if (v == null) return 0;
+            return v.ToObject<int>();
+        }
+        public void LoadFrom(string directory)
+        {
+            
+            JObject typesJson;
+            using (StreamReader fs = File.OpenText(Path.Combine(directory, "structs_and_enums.json")))
+            using (JsonTextReader jr = new JsonTextReader(fs))
+            {
+                typesJson = JObject.Load(jr);
+            }
+
+            JObject functionsJson;
+            using (StreamReader fs = File.OpenText(Path.Combine(directory, "definitions.json")))
+            using (JsonTextReader jr = new JsonTextReader(fs))
+            {
+                functionsJson = JObject.Load(jr);
+            }
+
+            JObject variantsJson = null;
+            if (File.Exists(Path.Combine(directory, "variants.json")))
+            {
+                using (StreamReader fs = File.OpenText(Path.Combine(directory, "variants.json")))
+                using (JsonTextReader jr = new JsonTextReader(fs))
+                {
+                    variantsJson = JObject.Load(jr);
+                }
+            }
+
+            Variants = new Dictionary<string, MethodVariant>();
+            foreach (var jt in variantsJson.Children())
+            {
+                JProperty jp = (JProperty)jt;
+                ParameterVariant[] methodVariants = jp.Values().Select(jv =>
+                {
+                    return new ParameterVariant(jv["name"].ToString(), jv["type"].ToString(), jv["variants"].Select(s => s.ToString()).ToArray());
+                }).ToArray();
+                Variants.Add(jp.Name, new MethodVariant(jp.Name, methodVariants));
+            }
+
+            var typeLocations = typesJson["locations"];
+
+            Enums = typesJson["enums"].Select(jt =>
+            {
+                JProperty jp = (JProperty)jt;
+                string name = jp.Name;
+                if (typeLocations?[jp.Name]?.Value<string>().Contains("internal") ?? false) {
+                    return null;
+                }
+                EnumMember[] elements = jp.Values().Select(v =>
+                {
+                    return new EnumMember(v["name"].ToString(), v["calc_value"].ToString());
+                }).ToArray();
+                return new EnumDefinition(name, elements);
+            }).Where(x => x != null).ToArray();
+
+            Types = typesJson["structs"].Select(jt =>
+            {
+                JProperty jp = (JProperty)jt;
+                string name = jp.Name;
+                if (typeLocations?[jp.Name]?.Value<string>().Contains("internal") ?? false) {
+                    return null;
+                }
+                TypeReference[] fields = jp.Values().Select(v =>
+                {
+                    if (v["type"].ToString().Contains("static")) { return null; }
+
+                    
+                    return new TypeReference(
+                        v["name"].ToString(),
+                        v["type"].ToString(),
+                            GetInt(v, "size"),
+                        v["template_type"]?.ToString(),
+                        Enums);
+                }).Where(tr => tr != null).ToArray();
+                return new TypeDefinition(name, fields);
+            }).Where(x => x != null).ToArray();
+
+            Functions = functionsJson.Children().Select(jt =>
+            {
+                JProperty jp = (JProperty)jt;
+                string name = jp.Name;
+                bool hasNonUdtVariants = jp.Values().Any(val => val["ov_cimguiname"]?.ToString().EndsWith("nonUDT") ?? false);
+                OverloadDefinition[] overloads = jp.Values().Select(val =>
+                {
+                    string ov_cimguiname = val["ov_cimguiname"]?.ToString();
+                    string cimguiname = val["cimguiname"].ToString();
+                    string friendlyName = val["funcname"]?.ToString();
+                    if (cimguiname.EndsWith("_destroy"))
+                    {
+                        friendlyName = "Destroy";
+                    }
+                    //skip internal functions
+                    var typename = val["stname"]?.ToString();
+                    if (!string.IsNullOrEmpty(typename))
+                    {
+                        if (!Types.Any(x => x.Name == val["stname"]?.ToString())) {
+                            return null;
+                        }
+                    }
+                    if (friendlyName == null) { return null; }
+                    if (val["location"]?.ToString().Contains("internal") ?? false) return null;
+
+                    string exportedName = ov_cimguiname;
+                    if (exportedName == null)
+                    {
+                        exportedName = cimguiname;
+                    }
+
+                    if (hasNonUdtVariants && !exportedName.EndsWith("nonUDT2"))
+                    {
+                        return null;
+                    }
+
+                    string selfTypeName = null;
+                    int underscoreIndex = exportedName.IndexOf('_');
+                    if (underscoreIndex > 0 && !exportedName.StartsWith("ig")) // Hack to exclude some weirdly-named non-instance functions.
+                    {
+                        selfTypeName = exportedName.Substring(0, underscoreIndex);
+                    }
+
+                    List<TypeReference> parameters = new List<TypeReference>();
+
+                    // find any variants that can be applied to the parameters of this method based on the method name
+                    MethodVariant methodVariants = null;
+                    Variants.TryGetValue(jp.Name, out methodVariants);
+
+                    foreach (JToken p in val["argsT"])
+                    {
+                        string pType = p["type"].ToString();
+                        string pName = p["name"].ToString();
+
+                        // if there are possible variants for this method then try to match them based on the parameter name and expected type
+                        ParameterVariant matchingVariant = methodVariants?.Parameters.Where(pv => pv.Name == pName && pv.OriginalType == pType).FirstOrDefault() ?? null;
+                        if (matchingVariant != null) matchingVariant.Used = true;
+
+                        parameters.Add(new TypeReference(pName, pType, 0, Enums, matchingVariant?.VariantTypes));
+                    }
+
+                    Dictionary<string, string> defaultValues = new Dictionary<string, string>();
+                    foreach (JToken dv in val["defaults"])
+                    {
+                        JProperty dvProp = (JProperty)dv;
+                        defaultValues.Add(dvProp.Name, dvProp.Value.ToString());
+                    }
+                    string returnType = val["ret"]?.ToString() ?? "void";
+                    string comment = null;
+
+                    string structName = val["stname"].ToString();
+                    bool isConstructor = val.Value<bool>("constructor");
+                    bool isDestructor = val.Value<bool>("destructor");
+                    if (isConstructor)
+                    {
+                        returnType = structName + "*";
+                    }
+
+                    return new OverloadDefinition(
+                        exportedName,
+                        friendlyName,
+                        parameters.ToArray(),
+                        defaultValues,
+                        returnType,
+                        structName,
+                        comment,
+                        isConstructor,
+                        isDestructor);
+                }).Where(od => od != null).ToArray();
+                if(overloads.Length == 0) return null;
+                return new FunctionDefinition(name, overloads, Enums);
+            }).Where(x => x != null).OrderBy(fd => fd.Name).ToArray();
+        }
+    }
+    
+    class MethodVariant
+    {
+        public string Name { get; }
+
+        public ParameterVariant[] Parameters { get; }
+
+        public MethodVariant(string name, ParameterVariant[] parameters)
+        {
+            Name = name;
+            Parameters = parameters;
+        }
+    }
+
+    class ParameterVariant
+    {
+        public string Name { get; }
+
+        public string OriginalType { get; }
+
+        public string[] VariantTypes { get; }
+
+        public bool Used { get; set; }
+
+        public ParameterVariant(string name, string originalType, string[] variantTypes)
+        {
+            Name = name;
+            OriginalType = originalType;
+            VariantTypes = variantTypes;
+            Used = false;
+        }
+    }
+
+    class EnumDefinition
+    {
+        private readonly Dictionary<string, string> _sanitizedNames;
+
+        public string[] Names { get; }
+        public string[] FriendlyNames { get; }
+        public EnumMember[] Members { get; }
+
+        public EnumDefinition(string name, EnumMember[] elements)
+        {
+            if (TypeInfo.AlternateEnumPrefixes.TryGetValue(name, out string altName))
+            {
+                Names = new[] { name, altName };
+            }
+            else
+            {
+                Names = new[] { name };
+            }
+            FriendlyNames = new string[Names.Length];
+            for (int i = 0; i < Names.Length; i++)
+            {
+                string n = Names[i];
+                if (n.EndsWith('_'))
+                {
+                    FriendlyNames[i] = n.Substring(0, n.Length - 1);
+                }
+                else
+                {
+                    FriendlyNames[i] = n;
+                }
+
+            }
+
+            Members = elements;
+
+            _sanitizedNames = new Dictionary<string, string>();
+            foreach (EnumMember el in elements)
+            {
+                _sanitizedNames.Add(el.Name, SanitizeMemberName(el.Name));
+            }
+        }
+
+        public string SanitizeNames(string text)
+        {
+            foreach (KeyValuePair<string, string> kvp in _sanitizedNames)
+            {
+                text = text.Replace(kvp.Key, kvp.Value);
+            }
+
+            return text;
+        }
+
+        private string SanitizeMemberName(string memberName)
+        {
+            string ret = memberName;
+            bool altSubstitution = false;
+
+            // Try alternate substitution first
+            foreach (KeyValuePair<string, string> substitutionPair in TypeInfo.AlternateEnumPrefixSubstitutions)
+            {
+                if (memberName.StartsWith(substitutionPair.Key))
+                {
+                    ret = ret.Replace(substitutionPair.Key, substitutionPair.Value);
+                    altSubstitution = true;
+                    break;
+                }
+            }
+
+            if (!altSubstitution)
+            {
+                foreach (string name in Names)
+                {
+                    if (memberName.StartsWith(name))
+                    {
+                        ret = memberName.Substring(name.Length);
+                        if (ret.StartsWith("_"))
+                        {
+                            ret = ret.Substring(1);
+                        }
+                    }
+                }
+            }
+
+            if (ret.EndsWith('_'))
+            {
+                ret = ret.Substring(0, ret.Length - 1);
+            }
+
+            if (char.IsDigit(ret.First()))
+                ret = "_" + ret;
+
+            return ret;
+        }
+    }
+
+    class EnumMember
+    {
+        public EnumMember(string name, string value)
+        {
+            Name = name;
+            Value = value;
+        }
+
+        public string Name { get; }
+        public string Value { get; }
+    }
+
+    class TypeDefinition
+    {
+        public string Name { get; }
+        public TypeReference[] Fields { get; }
+
+        public TypeDefinition(string name, TypeReference[] fields)
+        {
+            Name = name;
+            Fields = fields;
+        }
+    }
+
+    class TypeReference
+    {
+        public string Name { get; }
+        public string Type { get; }
+        public string TemplateType { get; }
+        public int ArraySize { get; }
+        public bool IsFunctionPointer { get; }
+        public string[] TypeVariants { get; }
+        public bool IsEnum { get; }
+
+        public TypeReference(string name, string type, int asize, EnumDefinition[] enums)
+            : this(name, type, asize, null, enums, null) { }
+
+        public TypeReference(string name, string type, int asize, EnumDefinition[] enums, string[] typeVariants)
+            : this(name, type, asize, null, enums, typeVariants) { }
+
+        public TypeReference(string name, string type, int asize, string templateType, EnumDefinition[] enums)
+            : this(name, type, asize, templateType, enums, null) { }
+
+        public TypeReference(string name, string type, int asize, string templateType, EnumDefinition[] enums, string[] typeVariants)
+        {
+            Name = name;
+            Type = type.Replace("const", string.Empty).Trim();
+
+
+            if (Type.StartsWith("ImVector_"))
+            {
+                if (Type.EndsWith("*"))
+                {
+                    Type = "ImVector*";
+                }
+                else
+                {
+                    Type = "ImVector";
+                }
+            }
+
+            if (Type.StartsWith("ImChunkStream_"))
+            {
+                if (Type.EndsWith("*"))
+                {
+                    Type = "ImChunkStream*";
+                }
+                else
+                {
+                    Type = "ImChunkStream";
+                }
+            }
+
+            TemplateType = templateType;
+            ArraySize = asize;
+            int startBracket = name.IndexOf('[');
+            if (startBracket != -1)
+            {
+                //This is only for older cimgui binding jsons
+                int endBracket = name.IndexOf(']');
+                string sizePart = name.Substring(startBracket + 1, endBracket - startBracket - 1);
+                if(ArraySize == 0)
+                    ArraySize = ParseSizeString(sizePart, enums);
+                Name = Name.Substring(0, startBracket);
+            }
+            IsFunctionPointer = Type.IndexOf('(') != -1;
+            
+            TypeVariants = typeVariants;
+
+            IsEnum = enums.Any(t => t.Names.Contains(type) || t.FriendlyNames.Contains(type) || TypeInfo.WellKnownEnums.Contains(type));
+        }
+        
+        private int ParseSizeString(string sizePart, EnumDefinition[] enums)
+        {
+            int plusStart = sizePart.IndexOf('+');
+            if (plusStart != -1)
+            {
+                string first = sizePart.Substring(0, plusStart);
+                string second = sizePart.Substring(plusStart, sizePart.Length - plusStart);
+                int firstVal = int.Parse(first);
+                int secondVal = int.Parse(second);
+                return firstVal + secondVal;
+            }
+
+            if (!int.TryParse(sizePart, out int ret))
+            {
+                foreach (EnumDefinition ed in enums)
+                {
+                    if (ed.Names.Any(n => sizePart.StartsWith(n)))
+                    {
+                        foreach (EnumMember member in ed.Members)
+                        {
+                            if (member.Name == sizePart)
+                            {
+                                return int.Parse(member.Value);
+                            }
+                        }
+                    }
+                }
+
+                ret = -1;
+            }
+
+            return ret;
+        }
+
+        public TypeReference WithVariant(int variantIndex, EnumDefinition[] enums)
+        {
+            if (variantIndex == 0) return this;
+            else return new TypeReference(Name, TypeVariants[variantIndex - 1], ArraySize, TemplateType, enums);
+        }
+    }
+
+    class FunctionDefinition
+    {
+        public string Name { get; }
+        public OverloadDefinition[] Overloads { get; }
+
+        public FunctionDefinition(string name, OverloadDefinition[] overloads, EnumDefinition[] enums)
+        {
+            Name = name;
+            Overloads = ExpandOverloadVariants(overloads, enums);
+        }
+
+        private OverloadDefinition[] ExpandOverloadVariants(OverloadDefinition[] overloads, EnumDefinition[] enums)
+        {
+            List<OverloadDefinition> newDefinitions = new List<OverloadDefinition>();
+
+            foreach (OverloadDefinition overload in overloads)
+            {
+                bool hasVariants = false;
+                int[] variantCounts = new int[overload.Parameters.Length];
+
+                for (int i = 0; i < overload.Parameters.Length; i++)
+                {
+                    if (overload.Parameters[i].TypeVariants != null)
+                    {
+                        hasVariants = true;
+                        variantCounts[i] = overload.Parameters[i].TypeVariants.Length + 1;
+                    }
+                    else
+                    {
+                        variantCounts[i] = 1;
+                    }
+                }
+
+                if (hasVariants)
+                {
+                    int totalVariants = variantCounts[0];
+                    for (int i = 1; i < variantCounts.Length; i++) totalVariants *= variantCounts[i];
+
+                    for (int i = 0; i < totalVariants; i++)
+                    {
+                        TypeReference[] parameters = new TypeReference[overload.Parameters.Length];
+                        int div = 1;
+
+                        for (int j = 0; j < parameters.Length; j++)
+                        {
+                            int k = (i / div) % variantCounts[j];
+
+                            parameters[j] = overload.Parameters[j].WithVariant(k, enums);
+
+                            if (j > 0) div *= variantCounts[j];
+                        }
+
+                        newDefinitions.Add(overload.WithParameters(parameters));
+                    }
+                }
+                else
+                {
+                    newDefinitions.Add(overload);
+                }
+            }
+
+            return newDefinitions.ToArray();
+        }
+    }
+
+    class OverloadDefinition
+    {
+        public string ExportedName { get; }
+        public string FriendlyName { get; }
+        public TypeReference[] Parameters { get; }
+        public Dictionary<string, string> DefaultValues { get; }
+        public string ReturnType { get; }
+        public string StructName { get; }
+        public bool IsMemberFunction { get; }
+        public string Comment { get; }
+        public bool IsConstructor { get; }
+        public bool IsDestructor { get; }
+
+        public OverloadDefinition(
+            string exportedName,
+            string friendlyName,
+            TypeReference[] parameters,
+            Dictionary<string, string> defaultValues,
+            string returnType,
+            string structName,
+            string comment,
+            bool isConstructor,
+            bool isDestructor)
+        {
+            ExportedName = exportedName;
+            FriendlyName = friendlyName;
+            Parameters = parameters;
+            DefaultValues = defaultValues;
+            ReturnType = returnType.Replace("const", string.Empty).Replace("inline", string.Empty).Trim();
+            StructName = structName;
+            IsMemberFunction = !string.IsNullOrEmpty(structName);
+            Comment = comment;
+            IsConstructor = isConstructor;
+            IsDestructor = isDestructor;
+        }
+
+        public OverloadDefinition WithParameters(TypeReference[] parameters)
+        {
+            return new OverloadDefinition(ExportedName, FriendlyName, parameters, DefaultValues, ReturnType, StructName, Comment, IsConstructor, IsDestructor);
+        }
+    }
+}
diff --git a/src/CodeGenerator/Program.cs b/src/CodeGenerator/Program.cs
index 7ce8a678..8597a718 100644
--- a/src/CodeGenerator/Program.cs
+++ b/src/CodeGenerator/Program.cs
@@ -7,101 +7,12 @@
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 
 namespace CodeGenerator
 {
-    class Program
+    internal static class Program
     {
-        private static readonly Dictionary<string, string> s_wellKnownTypes = new Dictionary<string, string>()
-        {
-            { "bool", "byte" },
-            { "unsigned char", "byte" },
-            { "char", "byte" },
-            { "ImWchar", "ushort" },
-            { "unsigned short", "ushort" },
-            { "unsigned int", "uint" },
-            { "ImVec2", "Vector2" },
-            { "ImVec2_Simple", "Vector2" },
-            { "ImVec3", "Vector3" },
-            { "ImVec4", "Vector4" },
-            { "ImVec4_Simple", "Vector4" },
-            { "ImColor_Simple", "ImColor" },
-            { "ImTextureID", "IntPtr" },
-            { "ImGuiID", "uint" },
-            { "ImDrawIdx", "ushort" },
-            { "ImDrawListSharedData", "IntPtr" },
-            { "ImDrawListSharedData*", "IntPtr" },
-            { "ImU32", "uint" },
-            { "ImDrawCallback", "IntPtr" },
-            { "size_t", "uint" },
-            { "ImGuiContext*", "IntPtr" },
-            { "float[2]", "Vector2*" },
-            { "float[3]", "Vector3*" },
-            { "float[4]", "Vector4*" },
-            { "int[2]", "int*" },
-            { "int[3]", "int*" },
-            { "int[4]", "int*" },
-            { "float&", "float*" },
-            { "ImVec2[2]", "Vector2*" },
-            { "char* []", "byte**" },
-        };
-
-        private static readonly Dictionary<string, string> s_wellKnownFieldReplacements = new Dictionary<string, string>()
-        {
-            { "bool", "bool" }, // Force bool to remain as bool in type-safe wrappers.
-        };
-
-        private static readonly HashSet<string> s_customDefinedTypes = new HashSet<string>()
-        {
-            "ImVector",
-            "ImVec2",
-            "ImVec4",
-            "Pair",
-        };
-
-        private static readonly Dictionary<string, string> s_wellKnownDefaultValues = new Dictionary<string, string>()
-        {
-            { "((void *)0)", "null" },
-            { "((void*)0)", "null" },
-            { "ImVec2(0,0)", "new Vector2()" },
-            { "ImVec2(-1,0)", "new Vector2(-1, 0)" },
-            { "ImVec2(1,0)", "new Vector2(1, 0)" },
-            { "ImVec2(1,1)", "new Vector2(1, 1)" },
-            { "ImVec2(0,1)", "new Vector2(0, 1)" },
-            { "ImVec4(0,0,0,0)", "new Vector4()" },
-            { "ImVec4(1,1,1,1)", "new Vector4(1, 1, 1, 1)" },
-            { "ImDrawCornerFlags_All", "(int)ImDrawCornerFlags.All" },
-            { "FLT_MAX", "float.MaxValue" },
-        };
-
-        private static readonly Dictionary<string, string> s_identifierReplacements = new Dictionary<string, string>()
-        {
-            { "in", "@in" },
-            { "out", "@out" },
-            { "ref", "@ref" },
-        };
-
-        private static readonly HashSet<string> s_legalFixedTypes = new HashSet<string>()
-        {
-            "byte",
-            "sbyte",
-            "char",
-            "ushort",
-            "short",
-            "uint",
-            "int",
-            "ulong",
-            "long",
-            "float",
-            "double",
-        };
-
-        private static readonly HashSet<string> s_skippedFunctions = new HashSet<string>()
-        {
-            "igInputText",
-            "igInputTextMultiline"
-        };
-
         static void Main(string[] args)
         {
             string outputPath;
@@ -113,125 +24,74 @@ static void Main(string[] args)
             {
                 outputPath = AppContext.BaseDirectory;
             }
-            Console.WriteLine($"Outputting generated code files to {outputPath}.");
 
-            JObject typesJson;
-            using (StreamReader fs = File.OpenText(Path.Combine(AppContext.BaseDirectory, "structs_and_enums.json")))
-            using (JsonTextReader jr = new JsonTextReader(fs))
+            if (!Directory.Exists(outputPath))
             {
-                typesJson = JObject.Load(jr);
+                Directory.CreateDirectory(outputPath);
             }
 
-            JObject functionsJson;
-            using (StreamReader fs = File.OpenText(Path.Combine(AppContext.BaseDirectory, "definitions.json")))
-            using (JsonTextReader jr = new JsonTextReader(fs))
+            string libraryName;
+            if (args.Length > 1)
             {
-                functionsJson = JObject.Load(jr);
+                libraryName = args[1];
             }
-
-            EnumDefinition[] enums = typesJson["enums"].Select(jt =>
+            else
             {
-                JProperty jp = (JProperty)jt;
-                string name = jp.Name;
-                EnumMember[] elements = jp.Values().Select(v =>
-                {
-                    return new EnumMember(v["name"].ToString(), v["value"].ToString());
-                }).ToArray();
-                return new EnumDefinition(name, elements);
-            }).ToArray();
+                libraryName = "cimgui";
+            }
 
-            TypeDefinition[] types = typesJson["structs"].Select(jt =>
+            string projectNamespace = libraryName switch
             {
-                JProperty jp = (JProperty)jt;
-                string name = jp.Name;
-                TypeReference[] fields = jp.Values().Select(v =>
-                {
-                    if (v["type"].ToString().Contains("static")) { return null; }
-
-                    return new TypeReference(
-                        v["name"].ToString(),
-                        v["type"].ToString(),
-                        v["template_type"]?.ToString(),
-                        enums);
-                }).Where(tr => tr != null).ToArray();
-                return new TypeDefinition(name, fields);
-            }).ToArray();
-
-            FunctionDefinition[] functions = functionsJson.Children().Select(jt =>
-            {
-                JProperty jp = (JProperty)jt;
-                string name = jp.Name;
-                bool hasNonUdtVariants = jp.Values().Any(val => val["ov_cimguiname"]?.ToString().EndsWith("nonUDT") ?? false);
-
-                OverloadDefinition[] overloads = jp.Values().Select(val =>
-                {
-                    string ov_cimguiname = val["ov_cimguiname"]?.ToString();
-                    string cimguiname = val["cimguiname"].ToString();
-                    string friendlyName = val["funcname"]?.ToString();
-                    if (friendlyName == null) { return null; }
+                "cimgui" => "ImGuiNET",
+                "cimplot" => "ImPlotNET",
+                "cimnodes" => "imnodesNET",
+                "cimguizmo" => "ImGuizmoNET",
+                _ => throw new NotImplementedException($"Library \"{libraryName}\" is not supported.")
+            };
 
-                    string exportedName = ov_cimguiname;
-                    if (exportedName == null)
-                    {
-                        exportedName = cimguiname;
-                    }
-
-                    if (hasNonUdtVariants && !exportedName.EndsWith("nonUDT2"))
-                    {
-                        return null;
-                    }
+            bool referencesImGui = libraryName switch
+            {
+                "cimgui" => false,
+                "cimplot" => true,
+                "cimnodes" => true,
+                "cimguizmo" => true,
+                _ => throw new NotImplementedException($"Library \"{libraryName}\" is not supported.")
+            };
 
-                    string selfTypeName = null;
-                    int underscoreIndex = exportedName.IndexOf('_');
-                    if (underscoreIndex > 0 && !exportedName.StartsWith("ig")) // Hack to exclude some weirdly-named non-instance functions.
-                    {
-                        selfTypeName = exportedName.Substring(0, underscoreIndex);
-                    }
+            string classPrefix = libraryName switch
+            {
+                "cimgui" => "ImGui",
+                "cimplot" => "ImPlot",
+                "cimnodes" => "imnodes",
+                "cimguizmo" => "ImGuizmo",
+                _ => throw new NotImplementedException($"Library \"{libraryName}\" is not supported.")
+            };
 
-                    List<TypeReference> parameters = new List<TypeReference>();
+            string dllName = libraryName switch
+            {
+                "cimgui" => "cimgui",
+                "cimplot" => "cimplot",
+                "cimnodes" => "cimnodes",
+                "cimguizmo" => "cimguizmo",
+                _ => throw new NotImplementedException()
+            };
+            
+            string definitionsPath = Path.Combine(AppContext.BaseDirectory, "definitions", libraryName);
+            var defs = new ImguiDefinitions();
+            defs.LoadFrom(definitionsPath);
 
-                    foreach (JToken p in val["argsT"])
-                    {
-                        string pType = p["type"].ToString();
-                        string pName = p["name"].ToString();
-                        parameters.Add(new TypeReference(pName, pType, enums));
-                    }
+            Console.WriteLine($"Outputting generated code files to {outputPath}.");
 
-                    Dictionary<string, string> defaultValues = new Dictionary<string, string>();
-                    foreach (JToken dv in val["defaults"])
-                    {
-                        JProperty dvProp = (JProperty)dv;
-                        defaultValues.Add(dvProp.Name, dvProp.Value.ToString());
-                    }
-                    string returnType = val["ret"]?.ToString() ?? "void";
-                    string comment = null;
-
-                    string structName = val["stname"].ToString();
-
-                    return new OverloadDefinition(
-                        exportedName,
-                        friendlyName,
-                        parameters.ToArray(),
-                        defaultValues,
-                        returnType,
-                        structName,
-                        comment,
-                        enums);
-                }).Where(od => od != null).ToArray();
-
-                return new FunctionDefinition(name, overloads);
-            }).OrderBy(fd => fd.Name).ToArray();
-
-            foreach (EnumDefinition ed in enums)
+            foreach (EnumDefinition ed in defs.Enums)
             {
-                using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, ed.FriendlyName + ".gen.cs")))
+                using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, ed.FriendlyNames[0] + ".gen.cs")))
                 {
-                    writer.PushBlock("namespace ImGuiNET");
-                    if (ed.FriendlyName.Contains("Flags"))
+                    writer.PushBlock($"namespace {projectNamespace}");
+                    if (ed.FriendlyNames[0].Contains("Flags"))
                     {
                         writer.WriteLine("[System.Flags]");
                     }
-                    writer.PushBlock($"public enum {ed.FriendlyName}");
+                    writer.PushBlock($"public enum {ed.FriendlyNames[0]}");
                     foreach (EnumMember member in ed.Members)
                     {
                         string sanitizedName = ed.SanitizeNames(member.Name);
@@ -243,9 +103,9 @@ static void Main(string[] args)
                 }
             }
 
-            foreach (TypeDefinition td in types)
+            foreach (TypeDefinition td in defs.Types)
             {
-                if (s_customDefinedTypes.Contains(td.Name)) { continue; }
+                if (TypeInfo.CustomDefinedTypes.Contains(td.Name)) { continue; }
 
                 using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, td.Name + ".gen.cs")))
                 {
@@ -253,8 +113,12 @@ static void Main(string[] args)
                     writer.Using("System.Numerics");
                     writer.Using("System.Runtime.CompilerServices");
                     writer.Using("System.Text");
+                    if (referencesImGui)
+                    {
+                        writer.Using("ImGuiNET");
+                    }
                     writer.WriteLine(string.Empty);
-                    writer.PushBlock("namespace ImGuiNET");
+                    writer.PushBlock($"namespace {projectNamespace}");
 
                     writer.PushBlock($"public unsafe partial struct {td.Name}");
                     foreach (TypeReference field in td.Fields)
@@ -263,7 +127,7 @@ static void Main(string[] args)
 
                         if (field.ArraySize != 0)
                         {
-                            if (s_legalFixedTypes.Contains(typeStr))
+                            if (TypeInfo.LegalFixedTypes.Contains(typeStr))
                             {
                                 writer.WriteLine($"public fixed {typeStr} {field.Name}[{field.ArraySize}];");
                             }
@@ -296,21 +160,21 @@ static void Main(string[] args)
                         string typeStr = GetTypeString(field.Type, field.IsFunctionPointer);
                         string rawType = typeStr;
 
-                        if (s_wellKnownFieldReplacements.TryGetValue(field.Type, out string wellKnownFieldType))
+                        if (TypeInfo.WellKnownFieldReplacements.TryGetValue(field.Type, out string wellKnownFieldType))
                         {
                             typeStr = wellKnownFieldType;
                         }
 
                         if (field.ArraySize != 0)
                         {
-                            string addrTarget = s_legalFixedTypes.Contains(rawType) ? $"NativePtr->{field.Name}" : $"&NativePtr->{field.Name}_0";
+                            string addrTarget = TypeInfo.LegalFixedTypes.Contains(rawType) ? $"NativePtr->{field.Name}" : $"&NativePtr->{field.Name}_0";
                             writer.WriteLine($"public RangeAccessor<{typeStr}> {field.Name} => new RangeAccessor<{typeStr}>({addrTarget}, {field.ArraySize});");
                         }
                         else if (typeStr.Contains("ImVector"))
                         {
                             string vectorElementType = GetTypeString(field.TemplateType, false);
 
-                            if (s_wellKnownTypes.TryGetValue(vectorElementType, out string wellKnown))
+                            if (TypeInfo.WellKnownTypes.TryGetValue(vectorElementType, out string wellKnown))
                             {
                                 vectorElementType = wellKnown;
                             }
@@ -352,7 +216,7 @@ static void Main(string[] args)
                         }
                     }
 
-                    foreach (FunctionDefinition fd in functions)
+                    foreach (FunctionDefinition fd in defs.Functions)
                     {
                         foreach (OverloadDefinition overload in fd.Overloads)
                         {
@@ -361,8 +225,10 @@ static void Main(string[] args)
                                 continue;
                             }
 
-                            if (overload.FriendlyName == overload.StructName)
+                            if (overload.IsConstructor)
                             {
+                                // TODO: Emit a static function on the type that invokes the native constructor.
+                                // Also, add a "Dispose" function or similar.
                                 continue;
                             }
 
@@ -399,7 +265,7 @@ static void Main(string[] args)
                                 {
                                     defaults.Add(orderedDefaults[j].Key, orderedDefaults[j].Value);
                                 }
-                                EmitOverload(writer, overload, defaults, "NativePtr");
+                                EmitOverload(writer, overload, defaults, "NativePtr", classPrefix);
                             }
                         }
                     }
@@ -409,20 +275,27 @@ static void Main(string[] args)
                 }
             }
 
-            using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, "ImGuiNative.gen.cs")))
+            using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, $"{classPrefix}Native.gen.cs")))
             {
                 writer.Using("System");
                 writer.Using("System.Numerics");
                 writer.Using("System.Runtime.InteropServices");
+                if (referencesImGui)
+                {
+                    writer.Using("ImGuiNET");
+                }
                 writer.WriteLine(string.Empty);
-                writer.PushBlock("namespace ImGuiNET");
-                writer.PushBlock("public static unsafe partial class ImGuiNative");
-                foreach (FunctionDefinition fd in functions)
+                writer.PushBlock($"namespace {projectNamespace}");
+                writer.PushBlock($"public static unsafe partial class {classPrefix}Native");
+                foreach (FunctionDefinition fd in defs.Functions)
                 {
                     foreach (OverloadDefinition overload in fd.Overloads)
                     {
                         string exportedName = overload.ExportedName;
                         if (exportedName.Contains("~")) { continue; }
+                        if (exportedName.Contains("ImVector_")) { continue; }
+                        if (exportedName.Contains("ImChunkStream_")) { continue; }
+
                         if (overload.Parameters.Any(tr => tr.Type.Contains('('))) { continue; } // TODO: Parse function pointer parameters.
 
                         string ret = GetTypeString(overload.ReturnType, false);
@@ -460,12 +333,12 @@ static void Main(string[] args)
 
                         if (isUdtVariant)
                         {
-                            writer.WriteLine($"[DllImport(\"cimgui\", CallingConvention = CallingConvention.Cdecl, EntryPoint = \"{exportedName}\")]");
+                            writer.WriteLine($"[DllImport(\"{dllName}\", CallingConvention = CallingConvention.Cdecl, EntryPoint = \"{exportedName}\")]");
 
                         }
                         else
                         {
-                            writer.WriteLine("[DllImport(\"cimgui\", CallingConvention = CallingConvention.Cdecl)]");
+                            writer.WriteLine($"[DllImport(\"{dllName}\", CallingConvention = CallingConvention.Cdecl)]");
                         }
                         writer.WriteLine($"public static extern {ret} {methodName}({parameters});");
                     }
@@ -474,18 +347,22 @@ static void Main(string[] args)
                 writer.PopBlock();
             }
 
-            using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, "ImGui.gen.cs")))
+            using (CSharpCodeWriter writer = new CSharpCodeWriter(Path.Combine(outputPath, $"{classPrefix}.gen.cs")))
             {
                 writer.Using("System");
                 writer.Using("System.Numerics");
                 writer.Using("System.Runtime.InteropServices");
                 writer.Using("System.Text");
+                if (referencesImGui)
+                {
+                    writer.Using("ImGuiNET");
+                }
                 writer.WriteLine(string.Empty);
-                writer.PushBlock("namespace ImGuiNET");
-                writer.PushBlock("public static unsafe partial class ImGui");
-                foreach (FunctionDefinition fd in functions)
+                writer.PushBlock($"namespace {projectNamespace}");
+                writer.PushBlock($"public static unsafe partial class {classPrefix}");
+                foreach (FunctionDefinition fd in defs.Functions)
                 {
-                    if (s_skippedFunctions.Contains(fd.Name)) { continue; }
+                    if (TypeInfo.SkippedFunctions.Contains(fd.Name)) { continue; }
 
                     foreach (OverloadDefinition overload in fd.Overloads)
                     {
@@ -496,6 +373,12 @@ static void Main(string[] args)
                         }
                         if (exportedName.Contains("~")) { continue; }
                         if (overload.Parameters.Any(tr => tr.Type.Contains('('))) { continue; } // TODO: Parse function pointer parameters.
+                        
+                        if ((overload.FriendlyName == "GetID" || overload.FriendlyName == "PushID") && overload.Parameters.Length > 1)
+                        {
+                            // skip ImGui.Get/PushID(start, end) overloads as they would overlap with existing
+                            continue;
+                        }
 
                         bool hasVaList = false;
                         for (int i = 0; i < overload.Parameters.Length; i++)
@@ -523,13 +406,21 @@ static void Main(string[] args)
                             {
                                 defaults.Add(orderedDefaults[j].Key, orderedDefaults[j].Value);
                             }
-                            EmitOverload(writer, overload, defaults, null);
+                            EmitOverload(writer, overload, defaults, null, classPrefix);
                         }
                     }
                 }
                 writer.PopBlock();
                 writer.PopBlock();
             }
+
+            foreach (var method in defs.Variants)
+            {
+                foreach (var variant in method.Value.Parameters)
+                {
+                    if (!variant.Used) Console.WriteLine($"Error: Variants targetting parameter {variant.Name} with type {variant.OriginalType} could not be applied to method {method.Key}.");
+                }
+            }
         }
 
         private static bool IsStringFieldName(string name)
@@ -560,11 +451,25 @@ private static void EmitOverload(
             CSharpCodeWriter writer,
             OverloadDefinition overload,
             Dictionary<string, string> defaultValues,
-            string selfName)
+            string selfName,
+            string classPrefix)
         {
-            if (overload.Parameters.Where(tr => tr.Name.EndsWith("_begin") || tr.Name.EndsWith("_end"))
-                .Any(tr => !defaultValues.ContainsKey(tr.Name)))
-            {
+            var rangeParams = overload.Parameters.Where(tr => 
+                tr.Name.EndsWith("_begin") || 
+                tr.Name.EndsWith("_end")).ToArray();
+            if (rangeParams.Any(tr => tr.Type != "char*"))
+            {
+                // only string supported for start/end. ImFont.IsGlyphRangeUnused is uint
+                return; 
+            }
+            if (rangeParams.Any(tr => tr.Name.EndsWith("_end") && defaultValues.ContainsKey(tr.Name)))
+            {
+                // we want overloads:
+                // (something, text_start, text_end (deleted), after=default)
+                // (something, text_start, text_end (deleted), after)
+                
+                // we dont need (as it would be duplicate)
+                // (something, text_start, text_end=default (deleted))
                 return;
             }
 
@@ -577,22 +482,33 @@ private static void EmitOverload(
                 safeRet = GetSafeType(overload.ReturnType);
             }
 
-            List<string> invocationArgs = new List<string>();
+            List<(string MarshalledType, string CorrectedIdentifier)> invocationArgs = new();
             MarshalledParameter[] marshalledParameters = new MarshalledParameter[overload.Parameters.Length];
             List<string> preCallLines = new List<string>();
             List<string> postCallLines = new List<string>();
             List<string> byRefParams = new List<string>();
-
+            int selfIndex = -1;
+            int pOutIndex = -1;
+            string overrideRet = null;
             for (int i = 0; i < overload.Parameters.Length; i++)
             {
-                if (i == 0 && selfName != null) { continue; }
-
                 TypeReference tr = overload.Parameters[i];
+                if (tr.Name == "self")
+                {
+                    selfIndex = i;
+                    continue; 
+                }
                 if (tr.Name == "...") { continue; }
 
                 string correctedIdentifier = CorrectIdentifier(tr.Name);
                 string nativeTypeName = GetTypeString(tr.Type, tr.IsFunctionPointer);
-
+                if (correctedIdentifier == "pOut" && overload.ReturnType == "void")
+                {
+                    pOutIndex = i;
+                    overrideRet = nativeTypeName.TrimEnd('*');
+                    preCallLines.Add($"{overrideRet} __retval;");
+                    continue;
+                }
                 if (tr.Type == "char*")
                 {
                     string textToEncode = correctedIdentifier;
@@ -617,9 +533,20 @@ private static void EmitOverload(
                     }
                     else
                     {
+                        if (tr.Name.EndsWith("_end"))
+                        {
+                            var startParamName = overload.Parameters[i-1].Name;
+                            var startNativeParamName = $"native_{startParamName}";
+                            marshalledParameters[i] = new MarshalledParameter(nativeTypeName, false, $"{startNativeParamName}+{startParamName}_byteCount", false);
+                            continue;
+                        }
+                        
+                        var checkForNull = !hasDefault && !tr.Name.EndsWith("_begin");
+                        // for string _begin the pointer passed must be non-null, so we'll set up an empty string if needed
+                        
                         preCallLines.Add($"byte* {nativeArgName};");
                         preCallLines.Add($"int {correctedIdentifier}_byteCount = 0;");
-                        if (!hasDefault)
+                        if (checkForNull)
                         {
                             preCallLines.Add($"if ({textToEncode} != null)");
                             preCallLines.Add("{");
@@ -636,8 +563,8 @@ private static void EmitOverload(
                         preCallLines.Add($"    }}");
                         preCallLines.Add($"    int {nativeArgName}_offset = Util.GetUtf8({textToEncode}, {nativeArgName}, {correctedIdentifier}_byteCount);");
                         preCallLines.Add($"    {nativeArgName}[{nativeArgName}_offset] = 0;");
-                        
-                        if (!hasDefault)
+
+                        if (checkForNull)
                         {
                             preCallLines.Add("}");
                             preCallLines.Add($"else {{ {nativeArgName} = null; }}");
@@ -649,6 +576,15 @@ private static void EmitOverload(
                         postCallLines.Add($"}}");
                     }
                 }
+                else if (defaultValues.TryGetValue(tr.Name, out string defaultVal))
+                {
+                    if (!CorrectDefaultValue(defaultVal, tr, out string correctedDefault))
+                    {
+                        correctedDefault = defaultVal;
+                    }
+                    marshalledParameters[i] = new MarshalledParameter(nativeTypeName, false, correctedIdentifier, true);
+                    preCallLines.Add($"{nativeTypeName} {correctedIdentifier} = {correctedDefault};");
+                }
                 else if (tr.Type == "char* []")
                 {
                     string nativeArgName = "native_" + tr.Name;
@@ -670,12 +606,8 @@ private static void EmitOverload(
                     preCallLines.Add($"for (int i = 0; i < {correctedIdentifier}.Length; i++)");
                     preCallLines.Add("{");
                     preCallLines.Add($"    string s = {correctedIdentifier}[i];");
-                    preCallLines.Add($"    fixed (char* sPtr = s)");
-                    preCallLines.Add("    {");
-                    preCallLines.Add($"        offset += Encoding.UTF8.GetBytes(sPtr, s.Length, {nativeArgName}_data + offset, {correctedIdentifier}_byteCounts[i]);");
-                    preCallLines.Add($"        {nativeArgName}_data[offset] = 0;");
-                    preCallLines.Add($"        offset += 1;");
-                    preCallLines.Add("    }");
+                    preCallLines.Add($"    offset += Util.GetUtf8(s, {nativeArgName}_data + offset, {correctedIdentifier}_byteCounts[i]);");
+                    preCallLines.Add($"    {nativeArgName}_data[offset++] = 0;");
                     preCallLines.Add("}");
 
                     preCallLines.Add($"byte** {nativeArgName} = stackalloc byte*[{correctedIdentifier}.Length];");
@@ -686,15 +618,6 @@ private static void EmitOverload(
                     preCallLines.Add($"    offset += {correctedIdentifier}_byteCounts[i] + 1;");
                     preCallLines.Add("}");
                 }
-                else if (defaultValues.TryGetValue(tr.Name, out string defaultVal))
-                {
-                    if (!CorrectDefaultValue(defaultVal, tr, out string correctedDefault))
-                    {
-                        correctedDefault = defaultVal;
-                    }
-                    marshalledParameters[i] = new MarshalledParameter(nativeTypeName, false, correctedIdentifier, true);
-                    preCallLines.Add($"{nativeTypeName} {correctedIdentifier} = {correctedDefault};");
-                }
                 else if (tr.Type == "bool")
                 {
                     string nativeArgName = "native_" + tr.Name;
@@ -717,20 +640,20 @@ private static void EmitOverload(
                     preCallLines.Add($"{nativePtrTypeName} {nativeArgName} = ({nativePtrTypeName}){correctedIdentifier}.ToPointer();");
                 }
                 else if (GetWrappedType(tr.Type, out string wrappedParamType)
-                    && !s_wellKnownTypes.ContainsKey(tr.Type)
-                    && !s_wellKnownTypes.ContainsKey(tr.Type.Substring(0, tr.Type.Length - 1)))
+                    && !TypeInfo.WellKnownTypes.ContainsKey(tr.Type)
+                    && !TypeInfo.WellKnownTypes.ContainsKey(tr.Type.Substring(0, tr.Type.Length - 1)))
                 {
                     marshalledParameters[i] = new MarshalledParameter(wrappedParamType, false, "native_" + tr.Name, false);
                     string nativeArgName = "native_" + tr.Name;
                     marshalledParameters[i] = new MarshalledParameter(wrappedParamType, false, nativeArgName, false);
                     preCallLines.Add($"{tr.Type} {nativeArgName} = {correctedIdentifier}.NativePtr;");
                 }
-                else if ((tr.Type.EndsWith("*") || tr.Type.Contains("[") || tr.Type.EndsWith("&")) && tr.Type != "void*" && tr.Type != "ImGuiContext*")
+                else if ((tr.Type.EndsWith("*") || tr.Type.Contains("[") || tr.Type.EndsWith("&")) && tr.Type != "void*" && tr.Type != "ImGuiContext*" && tr.Type != "ImPlotContext*"&& tr.Type != "EditorContext*")
                 {
                     string nonPtrType;
                     if (tr.Type.Contains("["))
                     {
-                        string wellKnown = s_wellKnownTypes[tr.Type];
+                        string wellKnown = TypeInfo.WellKnownTypes[tr.Type];
                         nonPtrType = GetTypeString(wellKnown.Substring(0, wellKnown.Length - 1), false);
                     }
                     else
@@ -750,30 +673,71 @@ private static void EmitOverload(
 
                 if (!marshalledParameters[i].HasDefaultValue)
                 {
-                    invocationArgs.Add($"{marshalledParameters[i].MarshalledType} {correctedIdentifier}");
+                    invocationArgs.Add((marshalledParameters[i].MarshalledType, correctedIdentifier));
                 }
             }
 
-            string invocationList = string.Join(", ", invocationArgs);
+            string invocationList = string.Join(", ", invocationArgs.Select(a => $"{a.MarshalledType} {a.CorrectedIdentifier}"));
             string friendlyName = overload.FriendlyName;
 
             string staticPortion = selfName == null ? "static " : string.Empty;
-            writer.PushBlock($"public {staticPortion}{safeRet} {friendlyName}({invocationList})");
-            foreach (string line in preCallLines)
+            
+            // When .NET Standard 2.1 is available, we can use ReadOnlySpan<char> instead of string, so generate additional overloads for methods containing string parameters.
+            if (invocationArgs.Count > 0 && invocationArgs.Any(a => a is { MarshalledType: "string" }))
             {
-                writer.WriteLine(line);
+                string readOnlySpanInvocationList = string.Join(", ", invocationArgs.Select(a => $"{(a.MarshalledType == "string" ? "ReadOnlySpan<char>" : a.MarshalledType)} {a.CorrectedIdentifier}"));
+
+                writer.WriteRaw("#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER");
+                WriteMethod(writer, overload, selfName, classPrefix, staticPortion, overrideRet, safeRet, friendlyName, readOnlySpanInvocationList, preCallLines, marshalledParameters, selfIndex, pOutIndex, nativeRet, postCallLines, isWrappedType);
+                writer.WriteRaw("#endif");
             }
 
-            List<string> nativeInvocationArgs = new List<string>();
+            WriteMethod(writer, overload, selfName, classPrefix, staticPortion, overrideRet, safeRet, friendlyName, invocationList, preCallLines, marshalledParameters, selfIndex, pOutIndex, nativeRet, postCallLines, isWrappedType);
+        }
 
-            if (selfName != null)
+        private static void WriteMethod(
+            CSharpCodeWriter writer,
+            OverloadDefinition overload,
+            string selfName,
+            string classPrefix,
+            string staticPortion,
+            string overrideRet,
+            string safeRet,
+            string friendlyName,
+            string invocationList,
+            List<string> preCallLines,
+            MarshalledParameter[] marshalledParameters,
+            int selfIndex,
+            int pOutIndex,
+            string nativeRet,
+            List<string> postCallLines,
+            bool isWrappedType)
+        {
+            writer.PushBlock($"public {staticPortion}{overrideRet ?? safeRet} {friendlyName}({invocationList})");
+
+            foreach (string line in preCallLines)
             {
-                nativeInvocationArgs.Add(selfName);
+                writer.WriteLine(line);
             }
 
+            List<string> nativeInvocationArgs = new();
+
             for (int i = 0; i < marshalledParameters.Length; i++)
             {
                 TypeReference tr = overload.Parameters[i];
+                if (selfIndex == i)
+                {
+                    //Some overloads seem to be generated with IntPtr as self
+                    //instead of the proper pointer type. TODO: investigate
+                    string tstr = GetTypeString(tr.Type, false);
+                    nativeInvocationArgs.Add($"({tstr})({selfName})");
+                    continue;
+                }
+                if (pOutIndex == i)
+                {
+                    nativeInvocationArgs.Add("&__retval");
+                    continue;
+                }
                 MarshalledParameter mp = marshalledParameters[i];
                 if (mp == null) { continue; }
                 if (mp.IsPinned)
@@ -794,7 +758,7 @@ private static void EmitOverload(
                 targetName = targetName.Substring(0, targetName.IndexOf("_nonUDT"));
             }
 
-            writer.WriteLine($"{ret}ImGuiNative.{targetName}({nativeInvocationStr});");
+            writer.WriteLine($"{ret}{classPrefix}Native.{targetName}({nativeInvocationStr});");
 
             foreach (string line in postCallLines)
             {
@@ -826,6 +790,9 @@ private static void EmitOverload(
                 }
             }
 
+            if (overrideRet != null)
+                writer.WriteLine("return __retval;");
+
             for (int i = 0; i < marshalledParameters.Length; i++)
             {
                 MarshalledParameter mp = marshalledParameters[i];
@@ -874,7 +841,7 @@ private static bool GetWrappedType(string nativeType, out string wrappedType)
                 }
                 string nonPtrType = nativeType.Substring(0, nativeType.Length - pointerLevel);
 
-                if (s_wellKnownTypes.ContainsKey(nonPtrType))
+                if (TypeInfo.WellKnownTypes.ContainsKey(nonPtrType))
                 {
                     wrappedType = null;
                     return false;
@@ -893,13 +860,13 @@ private static bool GetWrappedType(string nativeType, out string wrappedType)
 
         private static bool CorrectDefaultValue(string defaultVal, TypeReference tr, out string correctedDefault)
         {
-            if (tr.Type == "ImGuiContext*")
+            if (tr.Type == "ImGuiContext*" || tr.Type == "ImPlotContext*" || tr.Type == "EditorContext*")
             {
                 correctedDefault = "IntPtr.Zero";
                 return true;
             }
 
-            if (s_wellKnownDefaultValues.TryGetValue(defaultVal, out correctedDefault)) { return true; }
+            if (TypeInfo.WellKnownDefaultValues.TryGetValue(defaultVal, out correctedDefault)) { return true; }
 
             if (tr.Type == "bool")
             {
@@ -909,6 +876,19 @@ private static bool CorrectDefaultValue(string defaultVal, TypeReference tr, out
 
             if (defaultVal.Contains("%")) { correctedDefault = null; return false; }
 
+            if (tr.IsEnum)
+            {
+                if (defaultVal.StartsWith("-"))
+                {
+                    correctedDefault = $"({tr.Type})({defaultVal})";
+                }
+                else
+                {
+                    correctedDefault = $"({tr.Type}){defaultVal}";
+                }
+                return true;
+            }
+
             correctedDefault = defaultVal;
             return true;
         }
@@ -919,13 +899,13 @@ private static string GetTypeString(string typeName, bool isFunctionPointer)
             if (typeName.EndsWith("**")) { pointerLevel = 2; }
             else if (typeName.EndsWith("*")) { pointerLevel = 1; }
 
-            if (!s_wellKnownTypes.TryGetValue(typeName, out string typeStr))
+            if (!TypeInfo.WellKnownTypes.TryGetValue(typeName, out string typeStr))
             {
-                if (s_wellKnownTypes.TryGetValue(typeName.Substring(0, typeName.Length - pointerLevel), out typeStr))
+                if (TypeInfo.WellKnownTypes.TryGetValue(typeName.Substring(0, typeName.Length - pointerLevel), out typeStr))
                 {
                     typeStr = typeStr + new string('*', pointerLevel);
                 }
-                else if (!s_wellKnownTypes.TryGetValue(typeName, out typeStr))
+                else if (!TypeInfo.WellKnownTypes.TryGetValue(typeName, out typeStr))
                 {
                     typeStr = typeName;
                     if (isFunctionPointer) { typeStr = "IntPtr"; }
@@ -937,7 +917,7 @@ private static string GetTypeString(string typeName, bool isFunctionPointer)
 
         private static string CorrectIdentifier(string identifier)
         {
-            if (s_identifierReplacements.TryGetValue(identifier, out string replacement))
+            if (TypeInfo.IdentifierReplacements.TryGetValue(identifier, out string replacement))
             {
                 return replacement;
             }
@@ -948,206 +928,6 @@ private static string CorrectIdentifier(string identifier)
         }
     }
 
-    class EnumDefinition
-    {
-        private readonly Dictionary<string, string> _sanitizedNames;
-
-        public string Name { get; }
-        public string FriendlyName { get; }
-        public EnumMember[] Members { get; }
-
-        public EnumDefinition(string name, EnumMember[] elements)
-        {
-            Name = name;
-            if (Name.EndsWith('_'))
-            {
-                FriendlyName = Name.Substring(0, Name.Length - 1);
-            }
-            else
-            {
-                FriendlyName = Name;
-            }
-            Members = elements;
-
-            _sanitizedNames = new Dictionary<string, string>();
-            foreach (EnumMember el in elements)
-            {
-                _sanitizedNames.Add(el.Name, SanitizeMemberName(el.Name));
-            }
-        }
-
-        public string SanitizeNames(string text)
-        {
-            foreach (KeyValuePair<string, string> kvp in _sanitizedNames)
-            {
-                text = text.Replace(kvp.Key, kvp.Value);
-            }
-
-            return text;
-        }
-
-        private string SanitizeMemberName(string memberName)
-        {
-            string ret = memberName;
-            if (memberName.StartsWith(Name))
-            {
-                ret = memberName.Substring(Name.Length);
-            }
-
-            if (ret.EndsWith('_'))
-            {
-                ret = ret.Substring(0, ret.Length - 1);
-            }
-
-            return ret;
-        }
-    }
-
-    class EnumMember
-    {
-        public EnumMember(string name, string value)
-        {
-            Name = name;
-            Value = value;
-        }
-
-        public string Name { get; }
-        public string Value { get; }
-    }
-
-    class TypeDefinition
-    {
-        public string Name { get; }
-        public TypeReference[] Fields { get; }
-
-        public TypeDefinition(string name, TypeReference[] fields)
-        {
-            Name = name;
-            Fields = fields;
-        }
-    }
-
-    class TypeReference
-    {
-        public string Name { get; }
-        public string Type { get; }
-        public string TemplateType { get; }
-        public int ArraySize { get; }
-        public bool IsFunctionPointer { get; }
-
-        public TypeReference(string name, string type, EnumDefinition[] enums)
-            : this(name, type, null, enums) { }
-
-        public TypeReference(string name, string type, string templateType, EnumDefinition[] enums)
-        {
-            Name = name;
-            Type = type.Replace("const", string.Empty).Trim();
-
-
-            if (Type.StartsWith("ImVector_"))
-            {
-                if (Type.EndsWith("*"))
-                {
-                    Type = "ImVector*";
-                }
-                else
-                {
-                    Type = "ImVector";
-                }
-            }
-
-            TemplateType = templateType;
-            int startBracket = name.IndexOf('[');
-            if (startBracket != -1)
-            {
-                int endBracket = name.IndexOf(']');
-                string sizePart = name.Substring(startBracket + 1, endBracket - startBracket - 1);
-                ArraySize = ParseSizeString(sizePart, enums);
-                Name = Name.Substring(0, startBracket);
-            }
-
-            IsFunctionPointer = Type.IndexOf('(') != -1;
-        }
-
-        private int ParseSizeString(string sizePart, EnumDefinition[] enums)
-        {
-            int plusStart = sizePart.IndexOf('+');
-            if (plusStart != -1)
-            {
-                string first = sizePart.Substring(0, plusStart);
-                string second = sizePart.Substring(plusStart, sizePart.Length - plusStart);
-                int firstVal = int.Parse(first);
-                int secondVal = int.Parse(second);
-                return firstVal + secondVal;
-            }
-
-            if (!int.TryParse(sizePart, out int ret))
-            {
-                foreach (EnumDefinition ed in enums)
-                {
-                    if (sizePart.StartsWith(ed.Name))
-                    {
-                        foreach (EnumMember member in ed.Members)
-                        {
-                            if (member.Name == sizePart)
-                            {
-                                return int.Parse(member.Value);
-                            }
-                        }
-                    }
-                }
-
-                ret = -1;
-            }
-
-            return ret;
-        }
-    }
-
-    class FunctionDefinition
-    {
-        public string Name { get; }
-        public OverloadDefinition[] Overloads { get; }
-
-        public FunctionDefinition(string name, OverloadDefinition[] overloads)
-        {
-            Name = name;
-            Overloads = overloads;
-        }
-    }
-
-    class OverloadDefinition
-    {
-        public string ExportedName { get; }
-        public string FriendlyName { get; }
-        public TypeReference[] Parameters { get; }
-        public Dictionary<string, string> DefaultValues { get; }
-        public string ReturnType { get; }
-        public string StructName { get; }
-        public bool IsMemberFunction { get; }
-        public string Comment { get; }
-
-        public OverloadDefinition(
-            string exportedName,
-            string friendlyName,
-            TypeReference[] parameters,
-            Dictionary<string, string> defaultValues,
-            string returnType,
-            string structName,
-            string comment,
-            EnumDefinition[] enums)
-        {
-            ExportedName = exportedName;
-            FriendlyName = friendlyName;
-            Parameters = parameters;
-            DefaultValues = defaultValues;
-            ReturnType = returnType.Replace("const", string.Empty).Replace("inline", string.Empty).Trim();
-            StructName = structName;
-            IsMemberFunction = structName != "ImGui";
-            Comment = comment;
-        }
-    }
-
     class MarshalledParameter
     {
         public MarshalledParameter(string marshalledType, bool isPinned, string varName, bool hasDefaultValue)
diff --git a/src/CodeGenerator/Properties/launchSettings.json b/src/CodeGenerator/Properties/launchSettings.json
deleted file mode 100644
index b0543eb0..00000000
--- a/src/CodeGenerator/Properties/launchSettings.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "CodeGenerator": {
-      "commandName": "Project",
-      "commandLineArgs": "E:\\projects\\imgui.net\\src\\ImGui.NET\\Generated"
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/CodeGenerator/TypeInfo.cs b/src/CodeGenerator/TypeInfo.cs
new file mode 100644
index 00000000..4b9d91a5
--- /dev/null
+++ b/src/CodeGenerator/TypeInfo.cs
@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+
+namespace CodeGenerator
+{
+    public class TypeInfo
+    {
+        public static readonly Dictionary<string, string> WellKnownTypes = new Dictionary<string, string>()
+        {
+            { "bool", "byte" },
+            { "unsigned char", "byte" },
+            { "signed char", "sbyte" },
+            { "char", "byte" },
+            { "ImWchar", "ushort" },
+            { "ImFileHandle", "IntPtr" },
+            { "ImU8", "byte" },
+            { "ImS8", "sbyte" },
+            { "ImU16", "ushort" },
+            { "ImS16", "short" },
+            { "ImU32", "uint" },
+            { "ImS32", "int" },
+            { "ImU64", "ulong" },
+            { "ImS64", "long" },
+            { "unsigned short", "ushort" },
+            { "unsigned int", "uint" },
+            { "ImVec2", "Vector2" },
+            { "ImVec2_Simple", "Vector2" },
+            { "ImVec3", "Vector3" },
+            { "ImVec4", "Vector4" },
+            { "ImWchar16", "ushort" }, //char is not blittable
+            { "ImVec4_Simple", "Vector4" },
+            { "ImColor_Simple", "ImColor" },
+            { "ImTextureID", "IntPtr" },
+            { "ImGuiID", "uint" },
+            { "ImDrawIdx", "ushort" },
+            { "ImDrawListSharedData", "IntPtr" },
+            { "ImDrawListSharedData*", "IntPtr" },
+            { "ImDrawCallback", "IntPtr" },
+            { "size_t", "uint" },
+            { "ImGuiContext*", "IntPtr" },
+            { "ImPlotContext*", "IntPtr" },
+            { "EditorContext*", "IntPtr" },
+            { "ImGuiMemAllocFunc", "IntPtr" },
+            { "ImGuiMemFreeFunc", "IntPtr" },
+            { "ImFontBuilderIO", "IntPtr" },
+            { "float[2]", "Vector2*" },
+            { "float[3]", "Vector3*" },
+            { "float[4]", "Vector4*" },
+            { "int[2]", "int*" },
+            { "int[3]", "int*" },
+            { "int[4]", "int*" },
+            { "float&", "float*" },
+            { "ImVec2[2]", "Vector2*" },
+            { "char* []", "byte**" },
+            { "unsigned char[256]", "byte*"},
+            { "ImPlotFormatter", "IntPtr" },
+            { "ImPlotGetter", "IntPtr" },
+            { "ImPlotTransform", "IntPtr" },
+            { "ImGuiKeyChord", "ImGuiKey" },
+            { "ImGuiSelectionUserData", "long" },
+        };
+        
+        public static readonly List<string> WellKnownEnums = new List<string>()
+        {
+            "ImGuiMouseButton"
+        };
+
+        public static readonly Dictionary<string, string> AlternateEnumPrefixes = new Dictionary<string, string>()
+        {
+            { "ImGuiKey", "ImGuiMod" },
+        };
+
+        public static readonly Dictionary<string, string> AlternateEnumPrefixSubstitutions = new Dictionary<string, string>()
+        {
+            { "ImGuiMod_", "Mod" },
+        };
+
+        public static readonly Dictionary<string, string> WellKnownFieldReplacements = new Dictionary<string, string>()
+        {
+            { "bool", "bool" }, // Force bool to remain as bool in type-safe wrappers.
+        };
+
+        public static readonly HashSet<string> CustomDefinedTypes = new HashSet<string>()
+        {
+            "ImVector",
+            "ImVec2",
+            "ImVec4",
+            "ImGuiStoragePair",
+        };
+
+        public static readonly Dictionary<string, string> WellKnownDefaultValues = new Dictionary<string, string>()
+        {
+            { "((void *)0)", "null" },
+            { "((void*)0)", "null" },
+            { "NULL", "null"},
+            { "nullptr", "null"},
+            { "ImVec2(0,0)", "new Vector2()" },
+            { "ImVec2(0.0f,0.0f)", "new Vector2()" },
+            { "ImVec2(-FLT_MIN,0)", "new Vector2(-float.MinValue, 0.0f)" },
+            { "ImVec2(-1,0)", "new Vector2(-1, 0)" },
+            { "ImVec2(1,0)", "new Vector2(1, 0)" },
+            { "ImVec2(1,1)", "new Vector2(1, 1)" },
+            { "ImVec2(0,1)", "new Vector2(0, 1)" },
+            { "ImVec4(0,0,0,0)", "new Vector4()" },
+            { "ImVec4(1,1,1,1)", "new Vector4(1, 1, 1, 1)" },
+            { "ImVec4(0,0,0,-1)", "new Vector4(0, 0, 0, -1)" },
+            { "ImPlotPoint(0,0)", "new ImPlotPoint { x = 0, y = 0 }" },
+            { "ImPlotPoint(1,1)", "new ImPlotPoint { x = 1, y = 1 }" },
+            { "ImDrawCornerFlags_All", "ImDrawCornerFlags.All" },
+            { "ImPlotFlags_None", "ImPlotFlags.None"},
+            { "ImPlotAxisFlags_None", "ImPlotAxisFlags.None"},
+            { "ImPlotAxisFlags_NoGridLines", "ImPlotAxisFlags.NoGridLines"},
+            { "ImGuiCond_Once", "ImGuiCond.Once"},
+            { "ImPlotOrientation_Vertical", "ImPlotOrientation.Vertical"},
+            { "PinShape_CircleFilled", "PinShape.CircleFilled"},
+            { "ImGuiPopupFlags_None", "ImGuiPopupFlags.None"},
+            { "ImGuiNavHighlightFlags_TypeDefault", "ImGuiNavHighlightFlags.TypeDefault"},
+            { "ImGuiKeyModFlags_Ctrl", "ImGuiKeyModFlags.Ctrl"},
+            { "ImPlotYAxis_1", "ImPlotYAxis._1"},
+            { "FLT_MAX", "float.MaxValue" },
+            { "(((ImU32)(255)<<24)|((ImU32)(255)<<16)|((ImU32)(255)<<8)|((ImU32)(255)<<0))", "0xFFFFFFFF" },
+            { "sizeof(ImU8)", "sizeof(byte)"},
+            { "sizeof(ImS8)", "sizeof(sbyte)"},
+            { "sizeof(ImU16)", "sizeof(ushort)"},
+            { "sizeof(ImS16)", "sizeof(short)"},
+            { "sizeof(ImU32)", "sizeof(uint)"},
+            { "sizeof(ImS32)", "sizeof(int)"},
+            { "sizeof(ImU64)", "sizeof(ulong)"},
+            { "sizeof(ImS64)", "sizeof(long)"},
+            { "ImPlotBin_Sturges", "(int)ImPlotBin.Sturges" },
+            { "ImPlotRect()", "new ImPlotRect()" },
+            { "ImPlotCond_Once", "ImPlotCond.Once" },
+            { "ImPlotRange()", "new ImPlotRange()" },
+            
+        };
+
+        public static readonly Dictionary<string, string> IdentifierReplacements = new Dictionary<string, string>()
+        {
+            { "in", "@in" },
+            { "out", "@out" },
+            { "ref", "@ref" },
+        };
+
+        public static readonly HashSet<string> LegalFixedTypes = new HashSet<string>()
+        {
+            "byte",
+            "sbyte",
+            "char",
+            "ushort",
+            "short",
+            "uint",
+            "int",
+            "ulong",
+            "long",
+            "float",
+            "double",
+        };
+
+        public static readonly HashSet<string> SkippedFunctions = new HashSet<string>()
+        {
+            "igInputText",
+            "igInputTextMultiline",
+            "igInputTextWithHint"
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions.json b/src/CodeGenerator/definitions.json
deleted file mode 100644
index 0cb02483..00000000
--- a/src/CodeGenerator/definitions.json
+++ /dev/null
@@ -1,14882 +0,0 @@
-{
-  "CustomRect_CustomRect": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "CustomRect_CustomRect",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "CustomRect",
-      "signature": "()",
-      "stname": "CustomRect"
-    }
-  ],
-  "CustomRect_IsPacked": [
-    {
-      "args": "(CustomRect* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "CustomRect*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "CustomRect_IsPacked",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsPacked",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "CustomRect"
-    }
-  ],
-  "CustomRect_destroy": [
-    {
-      "args": "(CustomRect* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "CustomRect*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "CustomRect_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "CustomRect_destroy",
-      "ret": "void",
-      "signature": "(CustomRect*)",
-      "stname": "CustomRect"
-    }
-  ],
-  "ImColor_HSV": [
-    {
-      "args": "(ImColor* self,float h,float s,float v,float a)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImColor*"
-        },
-        {
-          "name": "h",
-          "type": "float"
-        },
-        {
-          "name": "s",
-          "type": "float"
-        },
-        {
-          "name": "v",
-          "type": "float"
-        },
-        {
-          "name": "a",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float h,float s,float v,float a=1.0f)",
-      "call_args": "(h,s,v,a)",
-      "cimguiname": "ImColor_HSV",
-      "comment": "",
-      "defaults": {
-        "a": "1.0f"
-      },
-      "funcname": "HSV",
-      "ret": "ImColor",
-      "signature": "(float,float,float,float)",
-      "stname": "ImColor"
-    },
-    {
-      "args": "(ImColor *pOut,ImColor* self,float h,float s,float v,float a)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImColor*"
-        },
-        {
-          "name": "self",
-          "type": "ImColor*"
-        },
-        {
-          "name": "h",
-          "type": "float"
-        },
-        {
-          "name": "s",
-          "type": "float"
-        },
-        {
-          "name": "v",
-          "type": "float"
-        },
-        {
-          "name": "a",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float h,float s,float v,float a=1.0f)",
-      "call_args": "(h,s,v,a)",
-      "cimguiname": "ImColor_HSV",
-      "comment": "",
-      "defaults": {
-        "a": "1.0f"
-      },
-      "funcname": "HSV",
-      "nonUDT": 1,
-      "ov_cimguiname": "ImColor_HSV_nonUDT",
-      "ret": "void",
-      "signature": "(float,float,float,float)",
-      "stname": "ImColor"
-    },
-    {
-      "args": "(ImColor* self,float h,float s,float v,float a)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImColor*"
-        },
-        {
-          "name": "h",
-          "type": "float"
-        },
-        {
-          "name": "s",
-          "type": "float"
-        },
-        {
-          "name": "v",
-          "type": "float"
-        },
-        {
-          "name": "a",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float h,float s,float v,float a=1.0f)",
-      "call_args": "(h,s,v,a)",
-      "cimguiname": "ImColor_HSV",
-      "comment": "",
-      "defaults": {
-        "a": "1.0f"
-      },
-      "funcname": "HSV",
-      "nonUDT": 2,
-      "ov_cimguiname": "ImColor_HSV_nonUDT2",
-      "ret": "ImColor_Simple",
-      "retorig": "ImColor",
-      "signature": "(float,float,float,float)",
-      "stname": "ImColor"
-    }
-  ],
-  "ImColor_ImColor": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImColor_ImColor",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImColor",
-      "ov_cimguiname": "ImColor_ImColor",
-      "signature": "()",
-      "stname": "ImColor"
-    },
-    {
-      "args": "(int r,int g,int b,int a)",
-      "argsT": [
-        {
-          "name": "r",
-          "type": "int"
-        },
-        {
-          "name": "g",
-          "type": "int"
-        },
-        {
-          "name": "b",
-          "type": "int"
-        },
-        {
-          "name": "a",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int r,int g,int b,int a=255)",
-      "call_args": "(r,g,b,a)",
-      "cimguiname": "ImColor_ImColor",
-      "comment": "",
-      "constructor": true,
-      "defaults": {
-        "a": "255"
-      },
-      "funcname": "ImColor",
-      "ov_cimguiname": "ImColor_ImColorInt",
-      "signature": "(int,int,int,int)",
-      "stname": "ImColor"
-    },
-    {
-      "args": "(ImU32 rgba)",
-      "argsT": [
-        {
-          "name": "rgba",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImU32 rgba)",
-      "call_args": "(rgba)",
-      "cimguiname": "ImColor_ImColor",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImColor",
-      "ov_cimguiname": "ImColor_ImColorU32",
-      "signature": "(ImU32)",
-      "stname": "ImColor"
-    },
-    {
-      "args": "(float r,float g,float b,float a)",
-      "argsT": [
-        {
-          "name": "r",
-          "type": "float"
-        },
-        {
-          "name": "g",
-          "type": "float"
-        },
-        {
-          "name": "b",
-          "type": "float"
-        },
-        {
-          "name": "a",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float r,float g,float b,float a=1.0f)",
-      "call_args": "(r,g,b,a)",
-      "cimguiname": "ImColor_ImColor",
-      "comment": "",
-      "constructor": true,
-      "defaults": {
-        "a": "1.0f"
-      },
-      "funcname": "ImColor",
-      "ov_cimguiname": "ImColor_ImColorFloat",
-      "signature": "(float,float,float,float)",
-      "stname": "ImColor"
-    },
-    {
-      "args": "(const ImVec4 col)",
-      "argsT": [
-        {
-          "name": "col",
-          "type": "const ImVec4"
-        }
-      ],
-      "argsoriginal": "(const ImVec4& col)",
-      "call_args": "(col)",
-      "cimguiname": "ImColor_ImColor",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImColor",
-      "ov_cimguiname": "ImColor_ImColorVec4",
-      "signature": "(const ImVec4)",
-      "stname": "ImColor"
-    }
-  ],
-  "ImColor_SetHSV": [
-    {
-      "args": "(ImColor* self,float h,float s,float v,float a)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImColor*"
-        },
-        {
-          "name": "h",
-          "type": "float"
-        },
-        {
-          "name": "s",
-          "type": "float"
-        },
-        {
-          "name": "v",
-          "type": "float"
-        },
-        {
-          "name": "a",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float h,float s,float v,float a=1.0f)",
-      "call_args": "(h,s,v,a)",
-      "cimguiname": "ImColor_SetHSV",
-      "comment": "",
-      "defaults": {
-        "a": "1.0f"
-      },
-      "funcname": "SetHSV",
-      "ret": "void",
-      "signature": "(float,float,float,float)",
-      "stname": "ImColor"
-    }
-  ],
-  "ImColor_destroy": [
-    {
-      "args": "(ImColor* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImColor*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImColor_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImColor_destroy",
-      "ret": "void",
-      "signature": "(ImColor*)",
-      "stname": "ImColor"
-    }
-  ],
-  "ImDrawCmd_ImDrawCmd": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawCmd_ImDrawCmd",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImDrawCmd",
-      "signature": "()",
-      "stname": "ImDrawCmd"
-    }
-  ],
-  "ImDrawCmd_destroy": [
-    {
-      "args": "(ImDrawCmd* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawCmd*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImDrawCmd_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImDrawCmd_destroy",
-      "ret": "void",
-      "signature": "(ImDrawCmd*)",
-      "stname": "ImDrawCmd"
-    }
-  ],
-  "ImDrawData_Clear": [
-    {
-      "args": "(ImDrawData* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawData*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawData_Clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawData"
-    }
-  ],
-  "ImDrawData_DeIndexAllBuffers": [
-    {
-      "args": "(ImDrawData* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawData*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawData_DeIndexAllBuffers",
-      "comment": "",
-      "defaults": [],
-      "funcname": "DeIndexAllBuffers",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawData"
-    }
-  ],
-  "ImDrawData_ImDrawData": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawData_ImDrawData",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImDrawData",
-      "signature": "()",
-      "stname": "ImDrawData"
-    }
-  ],
-  "ImDrawData_ScaleClipRects": [
-    {
-      "args": "(ImDrawData* self,const ImVec2 sc)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawData*"
-        },
-        {
-          "name": "sc",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& sc)",
-      "call_args": "(sc)",
-      "cimguiname": "ImDrawData_ScaleClipRects",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ScaleClipRects",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImDrawData"
-    }
-  ],
-  "ImDrawData_destroy": [
-    {
-      "args": "(ImDrawData* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawData*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImDrawData_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImDrawData_destroy",
-      "ret": "void",
-      "signature": "(ImDrawData*)",
-      "stname": "ImDrawData"
-    }
-  ],
-  "ImDrawList_AddBezierCurve": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "pos0",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cp0",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cp1",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "pos1",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        },
-        {
-          "name": "num_segments",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos0,const ImVec2& cp0,const ImVec2& cp1,const ImVec2& pos1,ImU32 col,float thickness,int num_segments=0)",
-      "call_args": "(pos0,cp0,cp1,pos1,col,thickness,num_segments)",
-      "cimguiname": "ImDrawList_AddBezierCurve",
-      "comment": "",
-      "defaults": {
-        "num_segments": "0"
-      },
-      "funcname": "AddBezierCurve",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddCallback": [
-    {
-      "args": "(ImDrawList* self,ImDrawCallback callback,void* callback_data)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "callback",
-          "type": "ImDrawCallback"
-        },
-        {
-          "name": "callback_data",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(ImDrawCallback callback,void* callback_data)",
-      "call_args": "(callback,callback_data)",
-      "cimguiname": "ImDrawList_AddCallback",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddCallback",
-      "ret": "void",
-      "signature": "(ImDrawCallback,void*)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddCircle": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "centre",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "radius",
-          "type": "float"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "num_segments",
-          "type": "int"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& centre,float radius,ImU32 col,int num_segments=12,float thickness=1.0f)",
-      "call_args": "(centre,radius,col,num_segments,thickness)",
-      "cimguiname": "ImDrawList_AddCircle",
-      "comment": "",
-      "defaults": {
-        "num_segments": "12",
-        "thickness": "1.0f"
-      },
-      "funcname": "AddCircle",
-      "ret": "void",
-      "signature": "(const ImVec2,float,ImU32,int,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddCircleFilled": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "centre",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "radius",
-          "type": "float"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "num_segments",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& centre,float radius,ImU32 col,int num_segments=12)",
-      "call_args": "(centre,radius,col,num_segments)",
-      "cimguiname": "ImDrawList_AddCircleFilled",
-      "comment": "",
-      "defaults": {
-        "num_segments": "12"
-      },
-      "funcname": "AddCircleFilled",
-      "ret": "void",
-      "signature": "(const ImVec2,float,ImU32,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddConvexPolyFilled": [
-    {
-      "args": "(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "points",
-          "type": "const ImVec2*"
-        },
-        {
-          "name": "num_points",
-          "type": "const int"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2* points,const int num_points,ImU32 col)",
-      "call_args": "(points,num_points,col)",
-      "cimguiname": "ImDrawList_AddConvexPolyFilled",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddConvexPolyFilled",
-      "ret": "void",
-      "signature": "(const ImVec2*,const int,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddDrawCmd": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_AddDrawCmd",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddDrawCmd",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddImage": [
-    {
-      "args": "(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "user_texture_id",
-          "type": "ImTextureID"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& a,const ImVec2& b,const ImVec2& uv_a=ImVec2(0,0),const ImVec2& uv_b=ImVec2(1,1),ImU32 col=0xFFFFFFFF)",
-      "call_args": "(user_texture_id,a,b,uv_a,uv_b,col)",
-      "cimguiname": "ImDrawList_AddImage",
-      "comment": "",
-      "defaults": {
-        "col": "0xFFFFFFFF",
-        "uv_a": "ImVec2(0,0)",
-        "uv_b": "ImVec2(1,1)"
-      },
-      "funcname": "AddImage",
-      "ret": "void",
-      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddImageQuad": [
-    {
-      "args": "(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "user_texture_id",
-          "type": "ImTextureID"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "d",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_d",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,const ImVec2& uv_a=ImVec2(0,0),const ImVec2& uv_b=ImVec2(1,0),const ImVec2& uv_c=ImVec2(1,1),const ImVec2& uv_d=ImVec2(0,1),ImU32 col=0xFFFFFFFF)",
-      "call_args": "(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col)",
-      "cimguiname": "ImDrawList_AddImageQuad",
-      "comment": "",
-      "defaults": {
-        "col": "0xFFFFFFFF",
-        "uv_a": "ImVec2(0,0)",
-        "uv_b": "ImVec2(1,0)",
-        "uv_c": "ImVec2(1,1)",
-        "uv_d": "ImVec2(0,1)"
-      },
-      "funcname": "AddImageQuad",
-      "ret": "void",
-      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddImageRounded": [
-    {
-      "args": "(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,int rounding_corners)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "user_texture_id",
-          "type": "ImTextureID"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "rounding",
-          "type": "float"
-        },
-        {
-          "name": "rounding_corners",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& a,const ImVec2& b,const ImVec2& uv_a,const ImVec2& uv_b,ImU32 col,float rounding,int rounding_corners=ImDrawCornerFlags_All)",
-      "call_args": "(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners)",
-      "cimguiname": "ImDrawList_AddImageRounded",
-      "comment": "",
-      "defaults": {
-        "rounding_corners": "ImDrawCornerFlags_All"
-      },
-      "funcname": "AddImageRounded",
-      "ret": "void",
-      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddLine": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,ImU32 col,float thickness=1.0f)",
-      "call_args": "(a,b,col,thickness)",
-      "cimguiname": "ImDrawList_AddLine",
-      "comment": "",
-      "defaults": {
-        "thickness": "1.0f"
-      },
-      "funcname": "AddLine",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddPolyline": [
-    {
-      "args": "(ImDrawList* self,const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "points",
-          "type": "const ImVec2*"
-        },
-        {
-          "name": "num_points",
-          "type": "const int"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "closed",
-          "type": "bool"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const ImVec2* points,const int num_points,ImU32 col,bool closed,float thickness)",
-      "call_args": "(points,num_points,col,closed,thickness)",
-      "cimguiname": "ImDrawList_AddPolyline",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddPolyline",
-      "ret": "void",
-      "signature": "(const ImVec2*,const int,ImU32,bool,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddQuad": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "d",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,ImU32 col,float thickness=1.0f)",
-      "call_args": "(a,b,c,d,col,thickness)",
-      "cimguiname": "ImDrawList_AddQuad",
-      "comment": "",
-      "defaults": {
-        "thickness": "1.0f"
-      },
-      "funcname": "AddQuad",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddQuadFilled": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "d",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,ImU32 col)",
-      "call_args": "(a,b,c,d,col)",
-      "cimguiname": "ImDrawList_AddQuadFilled",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddQuadFilled",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddRect": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "rounding",
-          "type": "float"
-        },
-        {
-          "name": "rounding_corners_flags",
-          "type": "int"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,ImU32 col,float rounding=0.0f,int rounding_corners_flags=ImDrawCornerFlags_All,float thickness=1.0f)",
-      "call_args": "(a,b,col,rounding,rounding_corners_flags,thickness)",
-      "cimguiname": "ImDrawList_AddRect",
-      "comment": "",
-      "defaults": {
-        "rounding": "0.0f",
-        "rounding_corners_flags": "ImDrawCornerFlags_All",
-        "thickness": "1.0f"
-      },
-      "funcname": "AddRect",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32,float,int,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddRectFilled": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,int rounding_corners_flags)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "rounding",
-          "type": "float"
-        },
-        {
-          "name": "rounding_corners_flags",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,ImU32 col,float rounding=0.0f,int rounding_corners_flags=ImDrawCornerFlags_All)",
-      "call_args": "(a,b,col,rounding,rounding_corners_flags)",
-      "cimguiname": "ImDrawList_AddRectFilled",
-      "comment": "",
-      "defaults": {
-        "rounding": "0.0f",
-        "rounding_corners_flags": "ImDrawCornerFlags_All"
-      },
-      "funcname": "AddRectFilled",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32,float,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddRectFilledMultiColor": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col_upr_left",
-          "type": "ImU32"
-        },
-        {
-          "name": "col_upr_right",
-          "type": "ImU32"
-        },
-        {
-          "name": "col_bot_right",
-          "type": "ImU32"
-        },
-        {
-          "name": "col_bot_left",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)",
-      "call_args": "(a,b,col_upr_left,col_upr_right,col_bot_right,col_bot_left)",
-      "cimguiname": "ImDrawList_AddRectFilledMultiColor",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddRectFilledMultiColor",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32,ImU32,ImU32,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddText": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "text_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos,ImU32 col,const char* text_begin,const char* text_end=((void*)0))",
-      "call_args": "(pos,col,text_begin,text_end)",
-      "cimguiname": "ImDrawList_AddText",
-      "comment": "",
-      "defaults": {
-        "text_end": "((void*)0)"
-      },
-      "funcname": "AddText",
-      "ov_cimguiname": "ImDrawList_AddText",
-      "ret": "void",
-      "signature": "(const ImVec2,ImU32,const char*,const char*)",
-      "stname": "ImDrawList"
-    },
-    {
-      "args": "(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "font",
-          "type": "const ImFont*"
-        },
-        {
-          "name": "font_size",
-          "type": "float"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "text_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        },
-        {
-          "name": "cpu_fine_clip_rect",
-          "type": "const ImVec4*"
-        }
-      ],
-      "argsoriginal": "(const ImFont* font,float font_size,const ImVec2& pos,ImU32 col,const char* text_begin,const char* text_end=((void*)0),float wrap_width=0.0f,const ImVec4* cpu_fine_clip_rect=((void*)0))",
-      "call_args": "(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect)",
-      "cimguiname": "ImDrawList_AddText",
-      "comment": "",
-      "defaults": {
-        "cpu_fine_clip_rect": "((void*)0)",
-        "text_end": "((void*)0)",
-        "wrap_width": "0.0f"
-      },
-      "funcname": "AddText",
-      "ov_cimguiname": "ImDrawList_AddTextFontPtr",
-      "ret": "void",
-      "signature": "(const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddTriangle": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,ImU32 col,float thickness=1.0f)",
-      "call_args": "(a,b,c,col,thickness)",
-      "cimguiname": "ImDrawList_AddTriangle",
-      "comment": "",
-      "defaults": {
-        "thickness": "1.0f"
-      },
-      "funcname": "AddTriangle",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,ImU32,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_AddTriangleFilled": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,ImU32 col)",
-      "call_args": "(a,b,c,col)",
-      "cimguiname": "ImDrawList_AddTriangleFilled",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddTriangleFilled",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_ChannelsMerge": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_ChannelsMerge",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ChannelsMerge",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_ChannelsSetCurrent": [
-    {
-      "args": "(ImDrawList* self,int channel_index)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "channel_index",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int channel_index)",
-      "call_args": "(channel_index)",
-      "cimguiname": "ImDrawList_ChannelsSetCurrent",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ChannelsSetCurrent",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_ChannelsSplit": [
-    {
-      "args": "(ImDrawList* self,int channels_count)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "channels_count",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int channels_count)",
-      "call_args": "(channels_count)",
-      "cimguiname": "ImDrawList_ChannelsSplit",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ChannelsSplit",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_Clear": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_Clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_ClearFreeMemory": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_ClearFreeMemory",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ClearFreeMemory",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_CloneOutput": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_CloneOutput",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CloneOutput",
-      "ret": "ImDrawList*",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_GetClipRectMax": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_GetClipRectMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipRectMax",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImDrawList"
-    },
-    {
-      "args": "(ImVec2 *pOut,ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_GetClipRectMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipRectMax",
-      "nonUDT": 1,
-      "ov_cimguiname": "ImDrawList_GetClipRectMax_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    },
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_GetClipRectMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipRectMax",
-      "nonUDT": 2,
-      "ov_cimguiname": "ImDrawList_GetClipRectMax_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_GetClipRectMin": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_GetClipRectMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipRectMin",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImDrawList"
-    },
-    {
-      "args": "(ImVec2 *pOut,ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_GetClipRectMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipRectMin",
-      "nonUDT": 1,
-      "ov_cimguiname": "ImDrawList_GetClipRectMin_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    },
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_GetClipRectMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipRectMin",
-      "nonUDT": 2,
-      "ov_cimguiname": "ImDrawList_GetClipRectMin_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_ImDrawList": [
-    {
-      "args": "(const ImDrawListSharedData* shared_data)",
-      "argsT": [
-        {
-          "name": "shared_data",
-          "type": "const ImDrawListSharedData*"
-        }
-      ],
-      "argsoriginal": "(const ImDrawListSharedData* shared_data)",
-      "call_args": "(shared_data)",
-      "cimguiname": "ImDrawList_ImDrawList",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImDrawList",
-      "signature": "(const ImDrawListSharedData*)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathArcTo": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "centre",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "radius",
-          "type": "float"
-        },
-        {
-          "name": "a_min",
-          "type": "float"
-        },
-        {
-          "name": "a_max",
-          "type": "float"
-        },
-        {
-          "name": "num_segments",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& centre,float radius,float a_min,float a_max,int num_segments=10)",
-      "call_args": "(centre,radius,a_min,a_max,num_segments)",
-      "cimguiname": "ImDrawList_PathArcTo",
-      "comment": "",
-      "defaults": {
-        "num_segments": "10"
-      },
-      "funcname": "PathArcTo",
-      "ret": "void",
-      "signature": "(const ImVec2,float,float,float,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathArcToFast": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "centre",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "radius",
-          "type": "float"
-        },
-        {
-          "name": "a_min_of_12",
-          "type": "int"
-        },
-        {
-          "name": "a_max_of_12",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& centre,float radius,int a_min_of_12,int a_max_of_12)",
-      "call_args": "(centre,radius,a_min_of_12,a_max_of_12)",
-      "cimguiname": "ImDrawList_PathArcToFast",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PathArcToFast",
-      "ret": "void",
-      "signature": "(const ImVec2,float,int,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathBezierCurveTo": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "p1",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "p2",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "p3",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "num_segments",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,int num_segments=0)",
-      "call_args": "(p1,p2,p3,num_segments)",
-      "cimguiname": "ImDrawList_PathBezierCurveTo",
-      "comment": "",
-      "defaults": {
-        "num_segments": "0"
-      },
-      "funcname": "PathBezierCurveTo",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathClear": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_PathClear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PathClear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathFillConvex": [
-    {
-      "args": "(ImDrawList* self,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImU32 col)",
-      "call_args": "(col)",
-      "cimguiname": "ImDrawList_PathFillConvex",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PathFillConvex",
-      "ret": "void",
-      "signature": "(ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathLineTo": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 pos)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos)",
-      "call_args": "(pos)",
-      "cimguiname": "ImDrawList_PathLineTo",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PathLineTo",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathLineToMergeDuplicate": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 pos)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos)",
-      "call_args": "(pos)",
-      "cimguiname": "ImDrawList_PathLineToMergeDuplicate",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PathLineToMergeDuplicate",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathRect": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,int rounding_corners_flags)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "rect_min",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "rect_max",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "rounding",
-          "type": "float"
-        },
-        {
-          "name": "rounding_corners_flags",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& rect_min,const ImVec2& rect_max,float rounding=0.0f,int rounding_corners_flags=ImDrawCornerFlags_All)",
-      "call_args": "(rect_min,rect_max,rounding,rounding_corners_flags)",
-      "cimguiname": "ImDrawList_PathRect",
-      "comment": "",
-      "defaults": {
-        "rounding": "0.0f",
-        "rounding_corners_flags": "ImDrawCornerFlags_All"
-      },
-      "funcname": "PathRect",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,float,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PathStroke": [
-    {
-      "args": "(ImDrawList* self,ImU32 col,bool closed,float thickness)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "closed",
-          "type": "bool"
-        },
-        {
-          "name": "thickness",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImU32 col,bool closed,float thickness=1.0f)",
-      "call_args": "(col,closed,thickness)",
-      "cimguiname": "ImDrawList_PathStroke",
-      "comment": "",
-      "defaults": {
-        "thickness": "1.0f"
-      },
-      "funcname": "PathStroke",
-      "ret": "void",
-      "signature": "(ImU32,bool,float)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PopClipRect": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_PopClipRect",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopClipRect",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PopTextureID": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_PopTextureID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopTextureID",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimQuadUV": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "d",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_c",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_d",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,const ImVec2& uv_a,const ImVec2& uv_b,const ImVec2& uv_c,const ImVec2& uv_d,ImU32 col)",
-      "call_args": "(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col)",
-      "cimguiname": "ImDrawList_PrimQuadUV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimQuadUV",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimRect": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,ImU32 col)",
-      "call_args": "(a,b,col)",
-      "cimguiname": "ImDrawList_PrimRect",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimRect",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimRectUV": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_a",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv_b",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& uv_a,const ImVec2& uv_b,ImU32 col)",
-      "call_args": "(a,b,uv_a,uv_b,col)",
-      "cimguiname": "ImDrawList_PrimRectUV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimRectUV",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimReserve": [
-    {
-      "args": "(ImDrawList* self,int idx_count,int vtx_count)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "idx_count",
-          "type": "int"
-        },
-        {
-          "name": "vtx_count",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int idx_count,int vtx_count)",
-      "call_args": "(idx_count,vtx_count)",
-      "cimguiname": "ImDrawList_PrimReserve",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimReserve",
-      "ret": "void",
-      "signature": "(int,int)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimVtx": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos,const ImVec2& uv,ImU32 col)",
-      "call_args": "(pos,uv,col)",
-      "cimguiname": "ImDrawList_PrimVtx",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimVtx",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimWriteIdx": [
-    {
-      "args": "(ImDrawList* self,ImDrawIdx idx)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "idx",
-          "type": "ImDrawIdx"
-        }
-      ],
-      "argsoriginal": "(ImDrawIdx idx)",
-      "call_args": "(idx)",
-      "cimguiname": "ImDrawList_PrimWriteIdx",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimWriteIdx",
-      "ret": "void",
-      "signature": "(ImDrawIdx)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PrimWriteVtx": [
-    {
-      "args": "(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos,const ImVec2& uv,ImU32 col)",
-      "call_args": "(pos,uv,col)",
-      "cimguiname": "ImDrawList_PrimWriteVtx",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PrimWriteVtx",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImU32)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PushClipRect": [
-    {
-      "args": "(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "clip_rect_min",
-          "type": "ImVec2"
-        },
-        {
-          "name": "clip_rect_max",
-          "type": "ImVec2"
-        },
-        {
-          "name": "intersect_with_current_clip_rect",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(ImVec2 clip_rect_min,ImVec2 clip_rect_max,bool intersect_with_current_clip_rect=false)",
-      "call_args": "(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect)",
-      "cimguiname": "ImDrawList_PushClipRect",
-      "comment": "",
-      "defaults": {
-        "intersect_with_current_clip_rect": "false"
-      },
-      "funcname": "PushClipRect",
-      "ret": "void",
-      "signature": "(ImVec2,ImVec2,bool)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PushClipRectFullScreen": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_PushClipRectFullScreen",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushClipRectFullScreen",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_PushTextureID": [
-    {
-      "args": "(ImDrawList* self,ImTextureID texture_id)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "texture_id",
-          "type": "ImTextureID"
-        }
-      ],
-      "argsoriginal": "(ImTextureID texture_id)",
-      "call_args": "(texture_id)",
-      "cimguiname": "ImDrawList_PushTextureID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushTextureID",
-      "ret": "void",
-      "signature": "(ImTextureID)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_UpdateClipRect": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_UpdateClipRect",
-      "comment": "",
-      "defaults": [],
-      "funcname": "UpdateClipRect",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_UpdateTextureID": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImDrawList_UpdateTextureID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "UpdateTextureID",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImDrawList_destroy": [
-    {
-      "args": "(ImDrawList* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImDrawList*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImDrawList_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImDrawList_destroy",
-      "ret": "void",
-      "signature": "(ImDrawList*)",
-      "stname": "ImDrawList"
-    }
-  ],
-  "ImFontAtlas_AddCustomRectFontGlyph": [
-    {
-      "args": "(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "font",
-          "type": "ImFont*"
-        },
-        {
-          "name": "id",
-          "type": "ImWchar"
-        },
-        {
-          "name": "width",
-          "type": "int"
-        },
-        {
-          "name": "height",
-          "type": "int"
-        },
-        {
-          "name": "advance_x",
-          "type": "float"
-        },
-        {
-          "name": "offset",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2& offset=ImVec2(0,0))",
-      "call_args": "(font,id,width,height,advance_x,offset)",
-      "cimguiname": "ImFontAtlas_AddCustomRectFontGlyph",
-      "comment": "",
-      "defaults": {
-        "offset": "ImVec2(0,0)"
-      },
-      "funcname": "AddCustomRectFontGlyph",
-      "ret": "int",
-      "signature": "(ImFont*,ImWchar,int,int,float,const ImVec2)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddCustomRectRegular": [
-    {
-      "args": "(ImFontAtlas* self,unsigned int id,int width,int height)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "id",
-          "type": "unsigned int"
-        },
-        {
-          "name": "width",
-          "type": "int"
-        },
-        {
-          "name": "height",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(unsigned int id,int width,int height)",
-      "call_args": "(id,width,height)",
-      "cimguiname": "ImFontAtlas_AddCustomRectRegular",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddCustomRectRegular",
-      "ret": "int",
-      "signature": "(unsigned int,int,int)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddFont": [
-    {
-      "args": "(ImFontAtlas* self,const ImFontConfig* font_cfg)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "font_cfg",
-          "type": "const ImFontConfig*"
-        }
-      ],
-      "argsoriginal": "(const ImFontConfig* font_cfg)",
-      "call_args": "(font_cfg)",
-      "cimguiname": "ImFontAtlas_AddFont",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddFont",
-      "ret": "ImFont*",
-      "signature": "(const ImFontConfig*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddFontDefault": [
-    {
-      "args": "(ImFontAtlas* self,const ImFontConfig* font_cfg)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "font_cfg",
-          "type": "const ImFontConfig*"
-        }
-      ],
-      "argsoriginal": "(const ImFontConfig* font_cfg=((void*)0))",
-      "call_args": "(font_cfg)",
-      "cimguiname": "ImFontAtlas_AddFontDefault",
-      "comment": "",
-      "defaults": {
-        "font_cfg": "((void*)0)"
-      },
-      "funcname": "AddFontDefault",
-      "ret": "ImFont*",
-      "signature": "(const ImFontConfig*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddFontFromFileTTF": [
-    {
-      "args": "(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "filename",
-          "type": "const char*"
-        },
-        {
-          "name": "size_pixels",
-          "type": "float"
-        },
-        {
-          "name": "font_cfg",
-          "type": "const ImFontConfig*"
-        },
-        {
-          "name": "glyph_ranges",
-          "type": "const ImWchar*"
-        }
-      ],
-      "argsoriginal": "(const char* filename,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
-      "call_args": "(filename,size_pixels,font_cfg,glyph_ranges)",
-      "cimguiname": "ImFontAtlas_AddFontFromFileTTF",
-      "comment": "",
-      "defaults": {
-        "font_cfg": "((void*)0)",
-        "glyph_ranges": "((void*)0)"
-      },
-      "funcname": "AddFontFromFileTTF",
-      "ret": "ImFont*",
-      "signature": "(const char*,float,const ImFontConfig*,const ImWchar*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddFontFromMemoryCompressedBase85TTF": [
-    {
-      "args": "(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "compressed_font_data_base85",
-          "type": "const char*"
-        },
-        {
-          "name": "size_pixels",
-          "type": "float"
-        },
-        {
-          "name": "font_cfg",
-          "type": "const ImFontConfig*"
-        },
-        {
-          "name": "glyph_ranges",
-          "type": "const ImWchar*"
-        }
-      ],
-      "argsoriginal": "(const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
-      "call_args": "(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges)",
-      "cimguiname": "ImFontAtlas_AddFontFromMemoryCompressedBase85TTF",
-      "comment": "",
-      "defaults": {
-        "font_cfg": "((void*)0)",
-        "glyph_ranges": "((void*)0)"
-      },
-      "funcname": "AddFontFromMemoryCompressedBase85TTF",
-      "ret": "ImFont*",
-      "signature": "(const char*,float,const ImFontConfig*,const ImWchar*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddFontFromMemoryCompressedTTF": [
-    {
-      "args": "(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "compressed_font_data",
-          "type": "const void*"
-        },
-        {
-          "name": "compressed_font_size",
-          "type": "int"
-        },
-        {
-          "name": "size_pixels",
-          "type": "float"
-        },
-        {
-          "name": "font_cfg",
-          "type": "const ImFontConfig*"
-        },
-        {
-          "name": "glyph_ranges",
-          "type": "const ImWchar*"
-        }
-      ],
-      "argsoriginal": "(const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
-      "call_args": "(compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges)",
-      "cimguiname": "ImFontAtlas_AddFontFromMemoryCompressedTTF",
-      "comment": "",
-      "defaults": {
-        "font_cfg": "((void*)0)",
-        "glyph_ranges": "((void*)0)"
-      },
-      "funcname": "AddFontFromMemoryCompressedTTF",
-      "ret": "ImFont*",
-      "signature": "(const void*,int,float,const ImFontConfig*,const ImWchar*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_AddFontFromMemoryTTF": [
-    {
-      "args": "(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "font_data",
-          "type": "void*"
-        },
-        {
-          "name": "font_size",
-          "type": "int"
-        },
-        {
-          "name": "size_pixels",
-          "type": "float"
-        },
-        {
-          "name": "font_cfg",
-          "type": "const ImFontConfig*"
-        },
-        {
-          "name": "glyph_ranges",
-          "type": "const ImWchar*"
-        }
-      ],
-      "argsoriginal": "(void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
-      "call_args": "(font_data,font_size,size_pixels,font_cfg,glyph_ranges)",
-      "cimguiname": "ImFontAtlas_AddFontFromMemoryTTF",
-      "comment": "",
-      "defaults": {
-        "font_cfg": "((void*)0)",
-        "glyph_ranges": "((void*)0)"
-      },
-      "funcname": "AddFontFromMemoryTTF",
-      "ret": "ImFont*",
-      "signature": "(void*,int,float,const ImFontConfig*,const ImWchar*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_Build": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_Build",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Build",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_CalcCustomRectUV": [
-    {
-      "args": "(ImFontAtlas* self,const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "rect",
-          "type": "const CustomRect*"
-        },
-        {
-          "name": "out_uv_min",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "out_uv_max",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "(const CustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)",
-      "call_args": "(rect,out_uv_min,out_uv_max)",
-      "cimguiname": "ImFontAtlas_CalcCustomRectUV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CalcCustomRectUV",
-      "ret": "void",
-      "signature": "(const CustomRect*,ImVec2*,ImVec2*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_Clear": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_Clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_ClearFonts": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_ClearFonts",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ClearFonts",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_ClearInputData": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_ClearInputData",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ClearInputData",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_ClearTexData": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_ClearTexData",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ClearTexData",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetCustomRectByIndex": [
-    {
-      "args": "(ImFontAtlas* self,int index)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "index",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int index)",
-      "call_args": "(index)",
-      "cimguiname": "ImFontAtlas_GetCustomRectByIndex",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCustomRectByIndex",
-      "ret": "const CustomRect*",
-      "signature": "(int)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesChineseFull": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesChineseFull",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesChineseFull",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesChineseSimplifiedCommon",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesCyrillic": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesCyrillic",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesCyrillic",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesDefault": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesDefault",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesDefault",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesJapanese": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesJapanese",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesJapanese",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesKorean": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesKorean",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesKorean",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetGlyphRangesThai": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_GetGlyphRangesThai",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetGlyphRangesThai",
-      "ret": "const ImWchar*",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetMouseCursorTexData": [
-    {
-      "args": "(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "cursor",
-          "type": "ImGuiMouseCursor"
-        },
-        {
-          "name": "out_offset",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "out_size",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "out_uv_border",
-          "type": "ImVec2[2]"
-        },
-        {
-          "name": "out_uv_fill",
-          "type": "ImVec2[2]"
-        }
-      ],
-      "argsoriginal": "(ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])",
-      "call_args": "(cursor,out_offset,out_size,out_uv_border,out_uv_fill)",
-      "cimguiname": "ImFontAtlas_GetMouseCursorTexData",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMouseCursorTexData",
-      "ret": "bool",
-      "signature": "(ImGuiMouseCursor,ImVec2*,ImVec2*,ImVec2[2],ImVec2[2])",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetTexDataAsAlpha8": [
-    {
-      "args": "(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "out_pixels",
-          "type": "unsigned char**"
-        },
-        {
-          "name": "out_width",
-          "type": "int*"
-        },
-        {
-          "name": "out_height",
-          "type": "int*"
-        },
-        {
-          "name": "out_bytes_per_pixel",
-          "type": "int*"
-        }
-      ],
-      "argsoriginal": "(unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel=((void*)0))",
-      "call_args": "(out_pixels,out_width,out_height,out_bytes_per_pixel)",
-      "cimguiname": "ImFontAtlas_GetTexDataAsAlpha8",
-      "comment": "",
-      "defaults": {
-        "out_bytes_per_pixel": "((void*)0)"
-      },
-      "funcname": "GetTexDataAsAlpha8",
-      "ret": "void",
-      "signature": "(unsigned char**,int*,int*,int*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_GetTexDataAsRGBA32": [
-    {
-      "args": "(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "out_pixels",
-          "type": "unsigned char**"
-        },
-        {
-          "name": "out_width",
-          "type": "int*"
-        },
-        {
-          "name": "out_height",
-          "type": "int*"
-        },
-        {
-          "name": "out_bytes_per_pixel",
-          "type": "int*"
-        }
-      ],
-      "argsoriginal": "(unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel=((void*)0))",
-      "call_args": "(out_pixels,out_width,out_height,out_bytes_per_pixel)",
-      "cimguiname": "ImFontAtlas_GetTexDataAsRGBA32",
-      "comment": "",
-      "defaults": {
-        "out_bytes_per_pixel": "((void*)0)"
-      },
-      "funcname": "GetTexDataAsRGBA32",
-      "ret": "void",
-      "signature": "(unsigned char**,int*,int*,int*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_ImFontAtlas": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_ImFontAtlas",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImFontAtlas",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_IsBuilt": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontAtlas_IsBuilt",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsBuilt",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_SetTexID": [
-    {
-      "args": "(ImFontAtlas* self,ImTextureID id)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        },
-        {
-          "name": "id",
-          "type": "ImTextureID"
-        }
-      ],
-      "argsoriginal": "(ImTextureID id)",
-      "call_args": "(id)",
-      "cimguiname": "ImFontAtlas_SetTexID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetTexID",
-      "ret": "void",
-      "signature": "(ImTextureID)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontAtlas_destroy": [
-    {
-      "args": "(ImFontAtlas* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImFontAtlas_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImFontAtlas_destroy",
-      "ret": "void",
-      "signature": "(ImFontAtlas*)",
-      "stname": "ImFontAtlas"
-    }
-  ],
-  "ImFontConfig_ImFontConfig": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontConfig_ImFontConfig",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImFontConfig",
-      "signature": "()",
-      "stname": "ImFontConfig"
-    }
-  ],
-  "ImFontConfig_destroy": [
-    {
-      "args": "(ImFontConfig* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontConfig*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImFontConfig_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImFontConfig_destroy",
-      "ret": "void",
-      "signature": "(ImFontConfig*)",
-      "stname": "ImFontConfig"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_AddChar": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImWchar c)",
-      "call_args": "(c)",
-      "cimguiname": "ImFontGlyphRangesBuilder_AddChar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddChar",
-      "ret": "void",
-      "signature": "(ImWchar)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_AddRanges": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        },
-        {
-          "name": "ranges",
-          "type": "const ImWchar*"
-        }
-      ],
-      "argsoriginal": "(const ImWchar* ranges)",
-      "call_args": "(ranges)",
-      "cimguiname": "ImFontGlyphRangesBuilder_AddRanges",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddRanges",
-      "ret": "void",
-      "signature": "(const ImWchar*)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_AddText": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        },
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
-      "call_args": "(text,text_end)",
-      "cimguiname": "ImFontGlyphRangesBuilder_AddText",
-      "comment": "",
-      "defaults": {
-        "text_end": "((void*)0)"
-      },
-      "funcname": "AddText",
-      "ret": "void",
-      "signature": "(const char*,const char*)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_BuildRanges": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        },
-        {
-          "name": "out_ranges",
-          "type": "ImVector_ImWchar*"
-        }
-      ],
-      "argsoriginal": "(ImVector<ImWchar>* out_ranges)",
-      "call_args": "(out_ranges)",
-      "cimguiname": "ImFontGlyphRangesBuilder_BuildRanges",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BuildRanges",
-      "ret": "void",
-      "signature": "(ImVector_ImWchar*)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_GetBit": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self,int n)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        },
-        {
-          "name": "n",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int n)",
-      "call_args": "(n)",
-      "cimguiname": "ImFontGlyphRangesBuilder_GetBit",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetBit",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImFontGlyphRangesBuilder",
-      "signature": "()",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_SetBit": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self,int n)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        },
-        {
-          "name": "n",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int n)",
-      "call_args": "(n)",
-      "cimguiname": "ImFontGlyphRangesBuilder_SetBit",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetBit",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFontGlyphRangesBuilder_destroy": [
-    {
-      "args": "(ImFontGlyphRangesBuilder* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFontGlyphRangesBuilder*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImFontGlyphRangesBuilder_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImFontGlyphRangesBuilder_destroy",
-      "ret": "void",
-      "signature": "(ImFontGlyphRangesBuilder*)",
-      "stname": "ImFontGlyphRangesBuilder"
-    }
-  ],
-  "ImFont_AddGlyph": [
-    {
-      "args": "(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        },
-        {
-          "name": "x0",
-          "type": "float"
-        },
-        {
-          "name": "y0",
-          "type": "float"
-        },
-        {
-          "name": "x1",
-          "type": "float"
-        },
-        {
-          "name": "y1",
-          "type": "float"
-        },
-        {
-          "name": "u0",
-          "type": "float"
-        },
-        {
-          "name": "v0",
-          "type": "float"
-        },
-        {
-          "name": "u1",
-          "type": "float"
-        },
-        {
-          "name": "v1",
-          "type": "float"
-        },
-        {
-          "name": "advance_x",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)",
-      "call_args": "(c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x)",
-      "cimguiname": "ImFont_AddGlyph",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddGlyph",
-      "ret": "void",
-      "signature": "(ImWchar,float,float,float,float,float,float,float,float,float)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_AddRemapChar": [
-    {
-      "args": "(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "dst",
-          "type": "ImWchar"
-        },
-        {
-          "name": "src",
-          "type": "ImWchar"
-        },
-        {
-          "name": "overwrite_dst",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(ImWchar dst,ImWchar src,bool overwrite_dst=true)",
-      "call_args": "(dst,src,overwrite_dst)",
-      "cimguiname": "ImFont_AddRemapChar",
-      "comment": "",
-      "defaults": {
-        "overwrite_dst": "true"
-      },
-      "funcname": "AddRemapChar",
-      "ret": "void",
-      "signature": "(ImWchar,ImWchar,bool)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_BuildLookupTable": [
-    {
-      "args": "(ImFont* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFont_BuildLookupTable",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BuildLookupTable",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_CalcTextSizeA": [
-    {
-      "args": "(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "size",
-          "type": "float"
-        },
-        {
-          "name": "max_width",
-          "type": "float"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        },
-        {
-          "name": "text_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "remaining",
-          "type": "const char**"
-        }
-      ],
-      "argsoriginal": "(float size,float max_width,float wrap_width,const char* text_begin,const char* text_end=((void*)0),const char** remaining=((void*)0))",
-      "call_args": "(size,max_width,wrap_width,text_begin,text_end,remaining)",
-      "cimguiname": "ImFont_CalcTextSizeA",
-      "comment": "",
-      "defaults": {
-        "remaining": "((void*)0)",
-        "text_end": "((void*)0)"
-      },
-      "funcname": "CalcTextSizeA",
-      "ret": "ImVec2",
-      "signature": "(float,float,float,const char*,const char*,const char**)",
-      "stname": "ImFont"
-    },
-    {
-      "args": "(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "size",
-          "type": "float"
-        },
-        {
-          "name": "max_width",
-          "type": "float"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        },
-        {
-          "name": "text_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "remaining",
-          "type": "const char**"
-        }
-      ],
-      "argsoriginal": "(float size,float max_width,float wrap_width,const char* text_begin,const char* text_end=((void*)0),const char** remaining=((void*)0))",
-      "call_args": "(size,max_width,wrap_width,text_begin,text_end,remaining)",
-      "cimguiname": "ImFont_CalcTextSizeA",
-      "comment": "",
-      "defaults": {
-        "remaining": "((void*)0)",
-        "text_end": "((void*)0)"
-      },
-      "funcname": "CalcTextSizeA",
-      "nonUDT": 1,
-      "ov_cimguiname": "ImFont_CalcTextSizeA_nonUDT",
-      "ret": "void",
-      "signature": "(float,float,float,const char*,const char*,const char**)",
-      "stname": "ImFont"
-    },
-    {
-      "args": "(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "size",
-          "type": "float"
-        },
-        {
-          "name": "max_width",
-          "type": "float"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        },
-        {
-          "name": "text_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "remaining",
-          "type": "const char**"
-        }
-      ],
-      "argsoriginal": "(float size,float max_width,float wrap_width,const char* text_begin,const char* text_end=((void*)0),const char** remaining=((void*)0))",
-      "call_args": "(size,max_width,wrap_width,text_begin,text_end,remaining)",
-      "cimguiname": "ImFont_CalcTextSizeA",
-      "comment": "",
-      "defaults": {
-        "remaining": "((void*)0)",
-        "text_end": "((void*)0)"
-      },
-      "funcname": "CalcTextSizeA",
-      "nonUDT": 2,
-      "ov_cimguiname": "ImFont_CalcTextSizeA_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "(float,float,float,const char*,const char*,const char**)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_CalcWordWrapPositionA": [
-    {
-      "args": "(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "scale",
-          "type": "float"
-        },
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float scale,const char* text,const char* text_end,float wrap_width)",
-      "call_args": "(scale,text,text_end,wrap_width)",
-      "cimguiname": "ImFont_CalcWordWrapPositionA",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CalcWordWrapPositionA",
-      "ret": "const char*",
-      "signature": "(float,const char*,const char*,float)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_ClearOutputData": [
-    {
-      "args": "(ImFont* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFont_ClearOutputData",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ClearOutputData",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_FindGlyph": [
-    {
-      "args": "(ImFont* self,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImWchar c)",
-      "call_args": "(c)",
-      "cimguiname": "ImFont_FindGlyph",
-      "comment": "",
-      "defaults": [],
-      "funcname": "FindGlyph",
-      "ret": "const ImFontGlyph*",
-      "signature": "(ImWchar)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_FindGlyphNoFallback": [
-    {
-      "args": "(ImFont* self,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImWchar c)",
-      "call_args": "(c)",
-      "cimguiname": "ImFont_FindGlyphNoFallback",
-      "comment": "",
-      "defaults": [],
-      "funcname": "FindGlyphNoFallback",
-      "ret": "const ImFontGlyph*",
-      "signature": "(ImWchar)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_GetCharAdvance": [
-    {
-      "args": "(ImFont* self,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImWchar c)",
-      "call_args": "(c)",
-      "cimguiname": "ImFont_GetCharAdvance",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCharAdvance",
-      "ret": "float",
-      "signature": "(ImWchar)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_GetDebugName": [
-    {
-      "args": "(ImFont* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFont_GetDebugName",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetDebugName",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_GrowIndex": [
-    {
-      "args": "(ImFont* self,int new_size)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "new_size",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int new_size)",
-      "call_args": "(new_size)",
-      "cimguiname": "ImFont_GrowIndex",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GrowIndex",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_ImFont": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFont_ImFont",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImFont",
-      "signature": "()",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_IsLoaded": [
-    {
-      "args": "(ImFont* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImFont_IsLoaded",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsLoaded",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_RenderChar": [
-    {
-      "args": "(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "draw_list",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "size",
-          "type": "float"
-        },
-        {
-          "name": "pos",
-          "type": "ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c)",
-      "call_args": "(draw_list,size,pos,col,c)",
-      "cimguiname": "ImFont_RenderChar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "RenderChar",
-      "ret": "void",
-      "signature": "(ImDrawList*,float,ImVec2,ImU32,ImWchar)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_RenderText": [
-    {
-      "args": "(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "draw_list",
-          "type": "ImDrawList*"
-        },
-        {
-          "name": "size",
-          "type": "float"
-        },
-        {
-          "name": "pos",
-          "type": "ImVec2"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        },
-        {
-          "name": "clip_rect",
-          "type": "const ImVec4"
-        },
-        {
-          "name": "text_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        },
-        {
-          "name": "cpu_fine_clip",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4& clip_rect,const char* text_begin,const char* text_end,float wrap_width=0.0f,bool cpu_fine_clip=false)",
-      "call_args": "(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip)",
-      "cimguiname": "ImFont_RenderText",
-      "comment": "",
-      "defaults": {
-        "cpu_fine_clip": "false",
-        "wrap_width": "0.0f"
-      },
-      "funcname": "RenderText",
-      "ret": "void",
-      "signature": "(ImDrawList*,float,ImVec2,ImU32,const ImVec4,const char*,const char*,float,bool)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_SetFallbackChar": [
-    {
-      "args": "(ImFont* self,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImWchar c)",
-      "call_args": "(c)",
-      "cimguiname": "ImFont_SetFallbackChar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetFallbackChar",
-      "ret": "void",
-      "signature": "(ImWchar)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImFont_destroy": [
-    {
-      "args": "(ImFont* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImFont*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImFont_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImFont_destroy",
-      "ret": "void",
-      "signature": "(ImFont*)",
-      "stname": "ImFont"
-    }
-  ],
-  "ImGuiIO_AddInputCharacter": [
-    {
-      "args": "(ImGuiIO* self,ImWchar c)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiIO*"
-        },
-        {
-          "name": "c",
-          "type": "ImWchar"
-        }
-      ],
-      "argsoriginal": "(ImWchar c)",
-      "call_args": "(c)",
-      "cimguiname": "ImGuiIO_AddInputCharacter",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddInputCharacter",
-      "ret": "void",
-      "signature": "(ImWchar)",
-      "stname": "ImGuiIO"
-    }
-  ],
-  "ImGuiIO_AddInputCharactersUTF8": [
-    {
-      "args": "(ImGuiIO* self,const char* str)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiIO*"
-        },
-        {
-          "name": "str",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str)",
-      "call_args": "(str)",
-      "cimguiname": "ImGuiIO_AddInputCharactersUTF8",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AddInputCharactersUTF8",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGuiIO"
-    }
-  ],
-  "ImGuiIO_ClearInputCharacters": [
-    {
-      "args": "(ImGuiIO* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiIO*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiIO_ClearInputCharacters",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ClearInputCharacters",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiIO"
-    }
-  ],
-  "ImGuiIO_ImGuiIO": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiIO_ImGuiIO",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImGuiIO",
-      "signature": "()",
-      "stname": "ImGuiIO"
-    }
-  ],
-  "ImGuiIO_destroy": [
-    {
-      "args": "(ImGuiIO* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiIO*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiIO_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiIO_destroy",
-      "ret": "void",
-      "signature": "(ImGuiIO*)",
-      "stname": "ImGuiIO"
-    }
-  ],
-  "ImGuiInputTextCallbackData_DeleteChars": [
-    {
-      "args": "(ImGuiInputTextCallbackData* self,int pos,int bytes_count)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiInputTextCallbackData*"
-        },
-        {
-          "name": "pos",
-          "type": "int"
-        },
-        {
-          "name": "bytes_count",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int pos,int bytes_count)",
-      "call_args": "(pos,bytes_count)",
-      "cimguiname": "ImGuiInputTextCallbackData_DeleteChars",
-      "comment": "",
-      "defaults": [],
-      "funcname": "DeleteChars",
-      "ret": "void",
-      "signature": "(int,int)",
-      "stname": "ImGuiInputTextCallbackData"
-    }
-  ],
-  "ImGuiInputTextCallbackData_HasSelection": [
-    {
-      "args": "(ImGuiInputTextCallbackData* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiInputTextCallbackData*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiInputTextCallbackData_HasSelection",
-      "comment": "",
-      "defaults": [],
-      "funcname": "HasSelection",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGuiInputTextCallbackData"
-    }
-  ],
-  "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImGuiInputTextCallbackData",
-      "signature": "()",
-      "stname": "ImGuiInputTextCallbackData"
-    }
-  ],
-  "ImGuiInputTextCallbackData_InsertChars": [
-    {
-      "args": "(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiInputTextCallbackData*"
-        },
-        {
-          "name": "pos",
-          "type": "int"
-        },
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(int pos,const char* text,const char* text_end=((void*)0))",
-      "call_args": "(pos,text,text_end)",
-      "cimguiname": "ImGuiInputTextCallbackData_InsertChars",
-      "comment": "",
-      "defaults": {
-        "text_end": "((void*)0)"
-      },
-      "funcname": "InsertChars",
-      "ret": "void",
-      "signature": "(int,const char*,const char*)",
-      "stname": "ImGuiInputTextCallbackData"
-    }
-  ],
-  "ImGuiInputTextCallbackData_destroy": [
-    {
-      "args": "(ImGuiInputTextCallbackData* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiInputTextCallbackData*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiInputTextCallbackData_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiInputTextCallbackData_destroy",
-      "ret": "void",
-      "signature": "(ImGuiInputTextCallbackData*)",
-      "stname": "ImGuiInputTextCallbackData"
-    }
-  ],
-  "ImGuiListClipper_Begin": [
-    {
-      "args": "(ImGuiListClipper* self,int items_count,float items_height)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiListClipper*"
-        },
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "items_height",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int items_count,float items_height=-1.0f)",
-      "call_args": "(items_count,items_height)",
-      "cimguiname": "ImGuiListClipper_Begin",
-      "comment": "",
-      "defaults": {
-        "items_height": "-1.0f"
-      },
-      "funcname": "Begin",
-      "ret": "void",
-      "signature": "(int,float)",
-      "stname": "ImGuiListClipper"
-    }
-  ],
-  "ImGuiListClipper_End": [
-    {
-      "args": "(ImGuiListClipper* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiListClipper*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiListClipper_End",
-      "comment": "",
-      "defaults": [],
-      "funcname": "End",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiListClipper"
-    }
-  ],
-  "ImGuiListClipper_ImGuiListClipper": [
-    {
-      "args": "(int items_count,float items_height)",
-      "argsT": [
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "items_height",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int items_count=-1,float items_height=-1.0f)",
-      "call_args": "(items_count,items_height)",
-      "cimguiname": "ImGuiListClipper_ImGuiListClipper",
-      "comment": "",
-      "constructor": true,
-      "defaults": {
-        "items_count": "-1",
-        "items_height": "-1.0f"
-      },
-      "funcname": "ImGuiListClipper",
-      "signature": "(int,float)",
-      "stname": "ImGuiListClipper"
-    }
-  ],
-  "ImGuiListClipper_Step": [
-    {
-      "args": "(ImGuiListClipper* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiListClipper*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiListClipper_Step",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Step",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGuiListClipper"
-    }
-  ],
-  "ImGuiListClipper_destroy": [
-    {
-      "args": "(ImGuiListClipper* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiListClipper*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiListClipper_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiListClipper_destroy",
-      "ret": "void",
-      "signature": "(ImGuiListClipper*)",
-      "stname": "ImGuiListClipper"
-    }
-  ],
-  "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImGuiOnceUponAFrame",
-      "signature": "()",
-      "stname": "ImGuiOnceUponAFrame"
-    }
-  ],
-  "ImGuiOnceUponAFrame_destroy": [
-    {
-      "args": "(ImGuiOnceUponAFrame* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiOnceUponAFrame*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiOnceUponAFrame_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiOnceUponAFrame_destroy",
-      "ret": "void",
-      "signature": "(ImGuiOnceUponAFrame*)",
-      "stname": "ImGuiOnceUponAFrame"
-    }
-  ],
-  "ImGuiPayload_Clear": [
-    {
-      "args": "(ImGuiPayload* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiPayload*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiPayload_Clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiPayload"
-    }
-  ],
-  "ImGuiPayload_ImGuiPayload": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiPayload_ImGuiPayload",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImGuiPayload",
-      "signature": "()",
-      "stname": "ImGuiPayload"
-    }
-  ],
-  "ImGuiPayload_IsDataType": [
-    {
-      "args": "(ImGuiPayload* self,const char* type)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiPayload*"
-        },
-        {
-          "name": "type",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* type)",
-      "call_args": "(type)",
-      "cimguiname": "ImGuiPayload_IsDataType",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsDataType",
-      "ret": "bool",
-      "signature": "(const char*)",
-      "stname": "ImGuiPayload"
-    }
-  ],
-  "ImGuiPayload_IsDelivery": [
-    {
-      "args": "(ImGuiPayload* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiPayload*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiPayload_IsDelivery",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsDelivery",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGuiPayload"
-    }
-  ],
-  "ImGuiPayload_IsPreview": [
-    {
-      "args": "(ImGuiPayload* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiPayload*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiPayload_IsPreview",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsPreview",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGuiPayload"
-    }
-  ],
-  "ImGuiPayload_destroy": [
-    {
-      "args": "(ImGuiPayload* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiPayload*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiPayload_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiPayload_destroy",
-      "ret": "void",
-      "signature": "(ImGuiPayload*)",
-      "stname": "ImGuiPayload"
-    }
-  ],
-  "ImGuiStorage_BuildSortByKey": [
-    {
-      "args": "(ImGuiStorage* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiStorage_BuildSortByKey",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BuildSortByKey",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_Clear": [
-    {
-      "args": "(ImGuiStorage* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiStorage_Clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetBool": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,bool default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,bool default_val=false)",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetBool",
-      "comment": "",
-      "defaults": {
-        "default_val": "false"
-      },
-      "funcname": "GetBool",
-      "ret": "bool",
-      "signature": "(ImGuiID,bool)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetBoolRef": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,bool default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,bool default_val=false)",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetBoolRef",
-      "comment": "",
-      "defaults": {
-        "default_val": "false"
-      },
-      "funcname": "GetBoolRef",
-      "ret": "bool*",
-      "signature": "(ImGuiID,bool)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetFloat": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,float default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,float default_val=0.0f)",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetFloat",
-      "comment": "",
-      "defaults": {
-        "default_val": "0.0f"
-      },
-      "funcname": "GetFloat",
-      "ret": "float",
-      "signature": "(ImGuiID,float)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetFloatRef": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,float default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,float default_val=0.0f)",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetFloatRef",
-      "comment": "",
-      "defaults": {
-        "default_val": "0.0f"
-      },
-      "funcname": "GetFloatRef",
-      "ret": "float*",
-      "signature": "(ImGuiID,float)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetInt": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,int default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,int default_val=0)",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetInt",
-      "comment": "",
-      "defaults": {
-        "default_val": "0"
-      },
-      "funcname": "GetInt",
-      "ret": "int",
-      "signature": "(ImGuiID,int)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetIntRef": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,int default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,int default_val=0)",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetIntRef",
-      "comment": "",
-      "defaults": {
-        "default_val": "0"
-      },
-      "funcname": "GetIntRef",
-      "ret": "int*",
-      "signature": "(ImGuiID,int)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetVoidPtr": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key)",
-      "call_args": "(key)",
-      "cimguiname": "ImGuiStorage_GetVoidPtr",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetVoidPtr",
-      "ret": "void*",
-      "signature": "(ImGuiID)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_GetVoidPtrRef": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,void* default_val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "default_val",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,void* default_val=((void*)0))",
-      "call_args": "(key,default_val)",
-      "cimguiname": "ImGuiStorage_GetVoidPtrRef",
-      "comment": "",
-      "defaults": {
-        "default_val": "((void*)0)"
-      },
-      "funcname": "GetVoidPtrRef",
-      "ret": "void**",
-      "signature": "(ImGuiID,void*)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_SetAllInt": [
-    {
-      "args": "(ImGuiStorage* self,int val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "val",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int val)",
-      "call_args": "(val)",
-      "cimguiname": "ImGuiStorage_SetAllInt",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetAllInt",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_SetBool": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,bool val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "val",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,bool val)",
-      "call_args": "(key,val)",
-      "cimguiname": "ImGuiStorage_SetBool",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetBool",
-      "ret": "void",
-      "signature": "(ImGuiID,bool)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_SetFloat": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,float val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "val",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,float val)",
-      "call_args": "(key,val)",
-      "cimguiname": "ImGuiStorage_SetFloat",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetFloat",
-      "ret": "void",
-      "signature": "(ImGuiID,float)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_SetInt": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,int val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "val",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,int val)",
-      "call_args": "(key,val)",
-      "cimguiname": "ImGuiStorage_SetInt",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetInt",
-      "ret": "void",
-      "signature": "(ImGuiID,int)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStorage_SetVoidPtr": [
-    {
-      "args": "(ImGuiStorage* self,ImGuiID key,void* val)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStorage*"
-        },
-        {
-          "name": "key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "val",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(ImGuiID key,void* val)",
-      "call_args": "(key,val)",
-      "cimguiname": "ImGuiStorage_SetVoidPtr",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetVoidPtr",
-      "ret": "void",
-      "signature": "(ImGuiID,void*)",
-      "stname": "ImGuiStorage"
-    }
-  ],
-  "ImGuiStyle_ImGuiStyle": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiStyle_ImGuiStyle",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImGuiStyle",
-      "signature": "()",
-      "stname": "ImGuiStyle"
-    }
-  ],
-  "ImGuiStyle_ScaleAllSizes": [
-    {
-      "args": "(ImGuiStyle* self,float scale_factor)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStyle*"
-        },
-        {
-          "name": "scale_factor",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float scale_factor)",
-      "call_args": "(scale_factor)",
-      "cimguiname": "ImGuiStyle_ScaleAllSizes",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ScaleAllSizes",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGuiStyle"
-    }
-  ],
-  "ImGuiStyle_destroy": [
-    {
-      "args": "(ImGuiStyle* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiStyle*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiStyle_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiStyle_destroy",
-      "ret": "void",
-      "signature": "(ImGuiStyle*)",
-      "stname": "ImGuiStyle"
-    }
-  ],
-  "ImGuiTextBuffer_ImGuiTextBuffer": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_ImGuiTextBuffer",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImGuiTextBuffer",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_appendf": [
-    {
-      "args": "(ImGuiTextBuffer* self,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "ImGuiTextBuffer_appendf",
-      "comment": "",
-      "defaults": [],
-      "funcname": "appendf",
-      "isvararg": "...)",
-      "manual": true,
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_appendfv": [
-    {
-      "args": "(ImGuiTextBuffer* self,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* fmt,va_list args)",
-      "call_args": "(fmt,args)",
-      "cimguiname": "ImGuiTextBuffer_appendfv",
-      "comment": "",
-      "defaults": [],
-      "funcname": "appendfv",
-      "ret": "void",
-      "signature": "(const char*,va_list)",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_begin": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_begin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "begin",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_c_str": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_c_str",
-      "comment": "",
-      "defaults": [],
-      "funcname": "c_str",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_clear": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_destroy": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiTextBuffer_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiTextBuffer_destroy",
-      "ret": "void",
-      "signature": "(ImGuiTextBuffer*)",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_empty": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_empty",
-      "comment": "",
-      "defaults": [],
-      "funcname": "empty",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_end": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_end",
-      "comment": "",
-      "defaults": [],
-      "funcname": "end",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_reserve": [
-    {
-      "args": "(ImGuiTextBuffer* self,int capacity)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        },
-        {
-          "name": "capacity",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int capacity)",
-      "call_args": "(capacity)",
-      "cimguiname": "ImGuiTextBuffer_reserve",
-      "comment": "",
-      "defaults": [],
-      "funcname": "reserve",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextBuffer_size": [
-    {
-      "args": "(ImGuiTextBuffer* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextBuffer*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextBuffer_size",
-      "comment": "",
-      "defaults": [],
-      "funcname": "size",
-      "ret": "int",
-      "signature": "()",
-      "stname": "ImGuiTextBuffer"
-    }
-  ],
-  "ImGuiTextFilter_Build": [
-    {
-      "args": "(ImGuiTextFilter* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextFilter*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextFilter_Build",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Build",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImGuiTextFilter_Clear": [
-    {
-      "args": "(ImGuiTextFilter* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextFilter*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextFilter_Clear",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Clear",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImGuiTextFilter_Draw": [
-    {
-      "args": "(ImGuiTextFilter* self,const char* label,float width)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextFilter*"
-        },
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label=\"Filter(inc,-exc)\",float width=0.0f)",
-      "call_args": "(label,width)",
-      "cimguiname": "ImGuiTextFilter_Draw",
-      "comment": "",
-      "defaults": {
-        "label": "\"Filter(inc,-exc)\"",
-        "width": "0.0f"
-      },
-      "funcname": "Draw",
-      "ret": "bool",
-      "signature": "(const char*,float)",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImGuiTextFilter_ImGuiTextFilter": [
-    {
-      "args": "(const char* default_filter)",
-      "argsT": [
-        {
-          "name": "default_filter",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* default_filter=\"\")",
-      "call_args": "(default_filter)",
-      "cimguiname": "ImGuiTextFilter_ImGuiTextFilter",
-      "comment": "",
-      "constructor": true,
-      "defaults": {
-        "default_filter": "\"\""
-      },
-      "funcname": "ImGuiTextFilter",
-      "signature": "(const char*)",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImGuiTextFilter_IsActive": [
-    {
-      "args": "(ImGuiTextFilter* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextFilter*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGuiTextFilter_IsActive",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsActive",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImGuiTextFilter_PassFilter": [
-    {
-      "args": "(ImGuiTextFilter* self,const char* text,const char* text_end)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextFilter*"
-        },
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
-      "call_args": "(text,text_end)",
-      "cimguiname": "ImGuiTextFilter_PassFilter",
-      "comment": "",
-      "defaults": {
-        "text_end": "((void*)0)"
-      },
-      "funcname": "PassFilter",
-      "ret": "bool",
-      "signature": "(const char*,const char*)",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImGuiTextFilter_destroy": [
-    {
-      "args": "(ImGuiTextFilter* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImGuiTextFilter*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImGuiTextFilter_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImGuiTextFilter_destroy",
-      "ret": "void",
-      "signature": "(ImGuiTextFilter*)",
-      "stname": "ImGuiTextFilter"
-    }
-  ],
-  "ImVec2_ImVec2": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImVec2_ImVec2",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImVec2",
-      "ov_cimguiname": "ImVec2_ImVec2",
-      "signature": "()",
-      "stname": "ImVec2"
-    },
-    {
-      "args": "(float _x,float _y)",
-      "argsT": [
-        {
-          "name": "_x",
-          "type": "float"
-        },
-        {
-          "name": "_y",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float _x,float _y)",
-      "call_args": "(_x,_y)",
-      "cimguiname": "ImVec2_ImVec2",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImVec2",
-      "ov_cimguiname": "ImVec2_ImVec2Float",
-      "signature": "(float,float)",
-      "stname": "ImVec2"
-    }
-  ],
-  "ImVec2_destroy": [
-    {
-      "args": "(ImVec2* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImVec2*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImVec2_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImVec2_destroy",
-      "ret": "void",
-      "signature": "(ImVec2*)",
-      "stname": "ImVec2"
-    }
-  ],
-  "ImVec4_ImVec4": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImVec4_ImVec4",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImVec4",
-      "ov_cimguiname": "ImVec4_ImVec4",
-      "signature": "()",
-      "stname": "ImVec4"
-    },
-    {
-      "args": "(float _x,float _y,float _z,float _w)",
-      "argsT": [
-        {
-          "name": "_x",
-          "type": "float"
-        },
-        {
-          "name": "_y",
-          "type": "float"
-        },
-        {
-          "name": "_z",
-          "type": "float"
-        },
-        {
-          "name": "_w",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float _x,float _y,float _z,float _w)",
-      "call_args": "(_x,_y,_z,_w)",
-      "cimguiname": "ImVec4_ImVec4",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "ImVec4",
-      "ov_cimguiname": "ImVec4_ImVec4Float",
-      "signature": "(float,float,float,float)",
-      "stname": "ImVec4"
-    }
-  ],
-  "ImVec4_destroy": [
-    {
-      "args": "(ImVec4* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "ImVec4*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "ImVec4_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "ImVec4_destroy",
-      "ret": "void",
-      "signature": "(ImVec4*)",
-      "stname": "ImVec4"
-    }
-  ],
-  "Pair_Pair": [
-    {
-      "args": "(ImGuiID _key,int _val_i)",
-      "argsT": [
-        {
-          "name": "_key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "_val_i",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(ImGuiID _key,int _val_i)",
-      "call_args": "(_key,_val_i)",
-      "cimguiname": "Pair_Pair",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "Pair",
-      "ov_cimguiname": "Pair_PairInt",
-      "signature": "(ImGuiID,int)",
-      "stname": "Pair"
-    },
-    {
-      "args": "(ImGuiID _key,float _val_f)",
-      "argsT": [
-        {
-          "name": "_key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "_val_f",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImGuiID _key,float _val_f)",
-      "call_args": "(_key,_val_f)",
-      "cimguiname": "Pair_Pair",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "Pair",
-      "ov_cimguiname": "Pair_PairFloat",
-      "signature": "(ImGuiID,float)",
-      "stname": "Pair"
-    },
-    {
-      "args": "(ImGuiID _key,void* _val_p)",
-      "argsT": [
-        {
-          "name": "_key",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "_val_p",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(ImGuiID _key,void* _val_p)",
-      "call_args": "(_key,_val_p)",
-      "cimguiname": "Pair_Pair",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "Pair",
-      "ov_cimguiname": "Pair_PairPtr",
-      "signature": "(ImGuiID,void*)",
-      "stname": "Pair"
-    }
-  ],
-  "Pair_destroy": [
-    {
-      "args": "(Pair* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "Pair*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "Pair_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "Pair_destroy",
-      "ret": "void",
-      "signature": "(Pair*)",
-      "stname": "Pair"
-    }
-  ],
-  "TextRange_TextRange": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "TextRange_TextRange",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "TextRange",
-      "ov_cimguiname": "TextRange_TextRange",
-      "signature": "()",
-      "stname": "TextRange"
-    },
-    {
-      "args": "(const char* _b,const char* _e)",
-      "argsT": [
-        {
-          "name": "_b",
-          "type": "const char*"
-        },
-        {
-          "name": "_e",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* _b,const char* _e)",
-      "call_args": "(_b,_e)",
-      "cimguiname": "TextRange_TextRange",
-      "comment": "",
-      "constructor": true,
-      "defaults": [],
-      "funcname": "TextRange",
-      "ov_cimguiname": "TextRange_TextRangeStr",
-      "signature": "(const char*,const char*)",
-      "stname": "TextRange"
-    }
-  ],
-  "TextRange_begin": [
-    {
-      "args": "(TextRange* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "TextRange*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "TextRange_begin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "begin",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "TextRange"
-    }
-  ],
-  "TextRange_destroy": [
-    {
-      "args": "(TextRange* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "TextRange*"
-        }
-      ],
-      "call_args": "(self)",
-      "cimguiname": "TextRange_destroy",
-      "defaults": [],
-      "destructor": true,
-      "ov_cimguiname": "TextRange_destroy",
-      "ret": "void",
-      "signature": "(TextRange*)",
-      "stname": "TextRange"
-    }
-  ],
-  "TextRange_empty": [
-    {
-      "args": "(TextRange* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "TextRange*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "TextRange_empty",
-      "comment": "",
-      "defaults": [],
-      "funcname": "empty",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "TextRange"
-    }
-  ],
-  "TextRange_end": [
-    {
-      "args": "(TextRange* self)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "TextRange*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "TextRange_end",
-      "comment": "",
-      "defaults": [],
-      "funcname": "end",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "TextRange"
-    }
-  ],
-  "TextRange_split": [
-    {
-      "args": "(TextRange* self,char separator,ImVector_TextRange* out)",
-      "argsT": [
-        {
-          "name": "self",
-          "type": "TextRange*"
-        },
-        {
-          "name": "separator",
-          "type": "char"
-        },
-        {
-          "name": "out",
-          "type": "ImVector_TextRange*"
-        }
-      ],
-      "argsoriginal": "(char separator,ImVector<TextRange>* out)",
-      "call_args": "(separator,out)",
-      "cimguiname": "TextRange_split",
-      "comment": "",
-      "defaults": [],
-      "funcname": "split",
-      "ret": "void",
-      "signature": "(char,ImVector_TextRange*)",
-      "stname": "TextRange"
-    }
-  ],
-  "igAcceptDragDropPayload": [
-    {
-      "args": "(const char* type,ImGuiDragDropFlags flags)",
-      "argsT": [
-        {
-          "name": "type",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiDragDropFlags"
-        }
-      ],
-      "argsoriginal": "(const char* type,ImGuiDragDropFlags flags=0)",
-      "call_args": "(type,flags)",
-      "cimguiname": "igAcceptDragDropPayload",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "AcceptDragDropPayload",
-      "ret": "const ImGuiPayload*",
-      "signature": "(const char*,ImGuiDragDropFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igAlignTextToFramePadding": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igAlignTextToFramePadding",
-      "comment": "",
-      "defaults": [],
-      "funcname": "AlignTextToFramePadding",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igArrowButton": [
-    {
-      "args": "(const char* str_id,ImGuiDir dir)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "dir",
-          "type": "ImGuiDir"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,ImGuiDir dir)",
-      "call_args": "(str_id,dir)",
-      "cimguiname": "igArrowButton",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ArrowButton",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDir)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBegin": [
-    {
-      "args": "(const char* name,bool* p_open,ImGuiWindowFlags flags)",
-      "argsT": [
-        {
-          "name": "name",
-          "type": "const char*"
-        },
-        {
-          "name": "p_open",
-          "type": "bool*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiWindowFlags"
-        }
-      ],
-      "argsoriginal": "(const char* name,bool* p_open=((void*)0),ImGuiWindowFlags flags=0)",
-      "call_args": "(name,p_open,flags)",
-      "cimguiname": "igBegin",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "p_open": "((void*)0)"
-      },
-      "funcname": "Begin",
-      "ret": "bool",
-      "signature": "(const char*,bool*,ImGuiWindowFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginChild": [
-    {
-      "args": "(const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "border",
-          "type": "bool"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiWindowFlags"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,const ImVec2& size=ImVec2(0,0),bool border=false,ImGuiWindowFlags flags=0)",
-      "call_args": "(str_id,size,border,flags)",
-      "cimguiname": "igBeginChild",
-      "comment": "",
-      "defaults": {
-        "border": "false",
-        "flags": "0",
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "BeginChild",
-      "ov_cimguiname": "igBeginChild",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2,bool,ImGuiWindowFlags)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImGuiID id,const ImVec2 size,bool border,ImGuiWindowFlags flags)",
-      "argsT": [
-        {
-          "name": "id",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "border",
-          "type": "bool"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiWindowFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiID id,const ImVec2& size=ImVec2(0,0),bool border=false,ImGuiWindowFlags flags=0)",
-      "call_args": "(id,size,border,flags)",
-      "cimguiname": "igBeginChild",
-      "comment": "",
-      "defaults": {
-        "border": "false",
-        "flags": "0",
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "BeginChild",
-      "ov_cimguiname": "igBeginChildID",
-      "ret": "bool",
-      "signature": "(ImGuiID,const ImVec2,bool,ImGuiWindowFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginChildFrame": [
-    {
-      "args": "(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags)",
-      "argsT": [
-        {
-          "name": "id",
-          "type": "ImGuiID"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiWindowFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiID id,const ImVec2& size,ImGuiWindowFlags flags=0)",
-      "call_args": "(id,size,flags)",
-      "cimguiname": "igBeginChildFrame",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "BeginChildFrame",
-      "ret": "bool",
-      "signature": "(ImGuiID,const ImVec2,ImGuiWindowFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginCombo": [
-    {
-      "args": "(const char* label,const char* preview_value,ImGuiComboFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "preview_value",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiComboFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,const char* preview_value,ImGuiComboFlags flags=0)",
-      "call_args": "(label,preview_value,flags)",
-      "cimguiname": "igBeginCombo",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "BeginCombo",
-      "ret": "bool",
-      "signature": "(const char*,const char*,ImGuiComboFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginDragDropSource": [
-    {
-      "args": "(ImGuiDragDropFlags flags)",
-      "argsT": [
-        {
-          "name": "flags",
-          "type": "ImGuiDragDropFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiDragDropFlags flags=0)",
-      "call_args": "(flags)",
-      "cimguiname": "igBeginDragDropSource",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "BeginDragDropSource",
-      "ret": "bool",
-      "signature": "(ImGuiDragDropFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginDragDropTarget": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igBeginDragDropTarget",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BeginDragDropTarget",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginGroup": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igBeginGroup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BeginGroup",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginMainMenuBar": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igBeginMainMenuBar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BeginMainMenuBar",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginMenu": [
-    {
-      "args": "(const char* label,bool enabled)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "enabled",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool enabled=true)",
-      "call_args": "(label,enabled)",
-      "cimguiname": "igBeginMenu",
-      "comment": "",
-      "defaults": {
-        "enabled": "true"
-      },
-      "funcname": "BeginMenu",
-      "ret": "bool",
-      "signature": "(const char*,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginMenuBar": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igBeginMenuBar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BeginMenuBar",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginPopup": [
-    {
-      "args": "(const char* str_id,ImGuiWindowFlags flags)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiWindowFlags"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,ImGuiWindowFlags flags=0)",
-      "call_args": "(str_id,flags)",
-      "cimguiname": "igBeginPopup",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "BeginPopup",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiWindowFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginPopupContextItem": [
-    {
-      "args": "(const char* str_id,int mouse_button)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "mouse_button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* str_id=((void*)0),int mouse_button=1)",
-      "call_args": "(str_id,mouse_button)",
-      "cimguiname": "igBeginPopupContextItem",
-      "comment": "",
-      "defaults": {
-        "mouse_button": "1",
-        "str_id": "((void*)0)"
-      },
-      "funcname": "BeginPopupContextItem",
-      "ret": "bool",
-      "signature": "(const char*,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginPopupContextVoid": [
-    {
-      "args": "(const char* str_id,int mouse_button)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "mouse_button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* str_id=((void*)0),int mouse_button=1)",
-      "call_args": "(str_id,mouse_button)",
-      "cimguiname": "igBeginPopupContextVoid",
-      "comment": "",
-      "defaults": {
-        "mouse_button": "1",
-        "str_id": "((void*)0)"
-      },
-      "funcname": "BeginPopupContextVoid",
-      "ret": "bool",
-      "signature": "(const char*,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginPopupContextWindow": [
-    {
-      "args": "(const char* str_id,int mouse_button,bool also_over_items)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "mouse_button",
-          "type": "int"
-        },
-        {
-          "name": "also_over_items",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const char* str_id=((void*)0),int mouse_button=1,bool also_over_items=true)",
-      "call_args": "(str_id,mouse_button,also_over_items)",
-      "cimguiname": "igBeginPopupContextWindow",
-      "comment": "",
-      "defaults": {
-        "also_over_items": "true",
-        "mouse_button": "1",
-        "str_id": "((void*)0)"
-      },
-      "funcname": "BeginPopupContextWindow",
-      "ret": "bool",
-      "signature": "(const char*,int,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginPopupModal": [
-    {
-      "args": "(const char* name,bool* p_open,ImGuiWindowFlags flags)",
-      "argsT": [
-        {
-          "name": "name",
-          "type": "const char*"
-        },
-        {
-          "name": "p_open",
-          "type": "bool*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiWindowFlags"
-        }
-      ],
-      "argsoriginal": "(const char* name,bool* p_open=((void*)0),ImGuiWindowFlags flags=0)",
-      "call_args": "(name,p_open,flags)",
-      "cimguiname": "igBeginPopupModal",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "p_open": "((void*)0)"
-      },
-      "funcname": "BeginPopupModal",
-      "ret": "bool",
-      "signature": "(const char*,bool*,ImGuiWindowFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginTabBar": [
-    {
-      "args": "(const char* str_id,ImGuiTabBarFlags flags)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTabBarFlags"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,ImGuiTabBarFlags flags=0)",
-      "call_args": "(str_id,flags)",
-      "cimguiname": "igBeginTabBar",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "BeginTabBar",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiTabBarFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginTabItem": [
-    {
-      "args": "(const char* label,bool* p_open,ImGuiTabItemFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "p_open",
-          "type": "bool*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTabItemFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool* p_open=((void*)0),ImGuiTabItemFlags flags=0)",
-      "call_args": "(label,p_open,flags)",
-      "cimguiname": "igBeginTabItem",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "p_open": "((void*)0)"
-      },
-      "funcname": "BeginTabItem",
-      "ret": "bool",
-      "signature": "(const char*,bool*,ImGuiTabItemFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBeginTooltip": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igBeginTooltip",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BeginTooltip",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igBullet": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igBullet",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Bullet",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igBulletText": [
-    {
-      "args": "(const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "igBulletText",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BulletText",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igBulletTextV": [
-    {
-      "args": "(const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* fmt,va_list args)",
-      "call_args": "(fmt,args)",
-      "cimguiname": "igBulletTextV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "BulletTextV",
-      "ret": "void",
-      "signature": "(const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igButton": [
-    {
-      "args": "(const char* label,const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* label,const ImVec2& size=ImVec2(0,0))",
-      "call_args": "(label,size)",
-      "cimguiname": "igButton",
-      "comment": "",
-      "defaults": {
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "Button",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCalcItemWidth": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igCalcItemWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CalcItemWidth",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igCalcListClipping": [
-    {
-      "args": "(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end)",
-      "argsT": [
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "items_height",
-          "type": "float"
-        },
-        {
-          "name": "out_items_display_start",
-          "type": "int*"
-        },
-        {
-          "name": "out_items_display_end",
-          "type": "int*"
-        }
-      ],
-      "argsoriginal": "(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end)",
-      "call_args": "(items_count,items_height,out_items_display_start,out_items_display_end)",
-      "cimguiname": "igCalcListClipping",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CalcListClipping",
-      "ret": "void",
-      "signature": "(int,float,int*,int*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCalcTextSize": [
-    {
-      "args": "(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)",
-      "argsT": [
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "hide_text_after_double_hash",
-          "type": "bool"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* text,const char* text_end=((void*)0),bool hide_text_after_double_hash=false,float wrap_width=-1.0f)",
-      "call_args": "(text,text_end,hide_text_after_double_hash,wrap_width)",
-      "cimguiname": "igCalcTextSize",
-      "comment": "",
-      "defaults": {
-        "hide_text_after_double_hash": "false",
-        "text_end": "((void*)0)",
-        "wrap_width": "-1.0f"
-      },
-      "funcname": "CalcTextSize",
-      "ret": "ImVec2",
-      "signature": "(const char*,const char*,bool,float)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "hide_text_after_double_hash",
-          "type": "bool"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* text,const char* text_end=((void*)0),bool hide_text_after_double_hash=false,float wrap_width=-1.0f)",
-      "call_args": "(text,text_end,hide_text_after_double_hash,wrap_width)",
-      "cimguiname": "igCalcTextSize",
-      "comment": "",
-      "defaults": {
-        "hide_text_after_double_hash": "false",
-        "text_end": "((void*)0)",
-        "wrap_width": "-1.0f"
-      },
-      "funcname": "CalcTextSize",
-      "nonUDT": 1,
-      "ov_cimguiname": "igCalcTextSize_nonUDT",
-      "ret": "void",
-      "signature": "(const char*,const char*,bool,float)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)",
-      "argsT": [
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        },
-        {
-          "name": "hide_text_after_double_hash",
-          "type": "bool"
-        },
-        {
-          "name": "wrap_width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* text,const char* text_end=((void*)0),bool hide_text_after_double_hash=false,float wrap_width=-1.0f)",
-      "call_args": "(text,text_end,hide_text_after_double_hash,wrap_width)",
-      "cimguiname": "igCalcTextSize",
-      "comment": "",
-      "defaults": {
-        "hide_text_after_double_hash": "false",
-        "text_end": "((void*)0)",
-        "wrap_width": "-1.0f"
-      },
-      "funcname": "CalcTextSize",
-      "nonUDT": 2,
-      "ov_cimguiname": "igCalcTextSize_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "(const char*,const char*,bool,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCaptureKeyboardFromApp": [
-    {
-      "args": "(bool want_capture_keyboard_value)",
-      "argsT": [
-        {
-          "name": "want_capture_keyboard_value",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(bool want_capture_keyboard_value=true)",
-      "call_args": "(want_capture_keyboard_value)",
-      "cimguiname": "igCaptureKeyboardFromApp",
-      "comment": "",
-      "defaults": {
-        "want_capture_keyboard_value": "true"
-      },
-      "funcname": "CaptureKeyboardFromApp",
-      "ret": "void",
-      "signature": "(bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCaptureMouseFromApp": [
-    {
-      "args": "(bool want_capture_mouse_value)",
-      "argsT": [
-        {
-          "name": "want_capture_mouse_value",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(bool want_capture_mouse_value=true)",
-      "call_args": "(want_capture_mouse_value)",
-      "cimguiname": "igCaptureMouseFromApp",
-      "comment": "",
-      "defaults": {
-        "want_capture_mouse_value": "true"
-      },
-      "funcname": "CaptureMouseFromApp",
-      "ret": "void",
-      "signature": "(bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCheckbox": [
-    {
-      "args": "(const char* label,bool* v)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "bool*"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool* v)",
-      "call_args": "(label,v)",
-      "cimguiname": "igCheckbox",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Checkbox",
-      "ret": "bool",
-      "signature": "(const char*,bool*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCheckboxFlags": [
-    {
-      "args": "(const char* label,unsigned int* flags,unsigned int flags_value)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "unsigned int*"
-        },
-        {
-          "name": "flags_value",
-          "type": "unsigned int"
-        }
-      ],
-      "argsoriginal": "(const char* label,unsigned int* flags,unsigned int flags_value)",
-      "call_args": "(label,flags,flags_value)",
-      "cimguiname": "igCheckboxFlags",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CheckboxFlags",
-      "ret": "bool",
-      "signature": "(const char*,unsigned int*,unsigned int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCloseCurrentPopup": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igCloseCurrentPopup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "CloseCurrentPopup",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igCollapsingHeader": [
-    {
-      "args": "(const char* label,ImGuiTreeNodeFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiTreeNodeFlags flags=0)",
-      "call_args": "(label,flags)",
-      "cimguiname": "igCollapsingHeader",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "CollapsingHeader",
-      "ov_cimguiname": "igCollapsingHeader",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiTreeNodeFlags)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,bool* p_open,ImGuiTreeNodeFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "p_open",
-          "type": "bool*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool* p_open,ImGuiTreeNodeFlags flags=0)",
-      "call_args": "(label,p_open,flags)",
-      "cimguiname": "igCollapsingHeader",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "CollapsingHeader",
-      "ov_cimguiname": "igCollapsingHeaderBoolPtr",
-      "ret": "bool",
-      "signature": "(const char*,bool*,ImGuiTreeNodeFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorButton": [
-    {
-      "args": "(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size)",
-      "argsT": [
-        {
-          "name": "desc_id",
-          "type": "const char*"
-        },
-        {
-          "name": "col",
-          "type": "const ImVec4"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiColorEditFlags"
-        },
-        {
-          "name": "size",
-          "type": "ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* desc_id,const ImVec4& col,ImGuiColorEditFlags flags=0,ImVec2 size=ImVec2(0,0))",
-      "call_args": "(desc_id,col,flags,size)",
-      "cimguiname": "igColorButton",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "ColorButton",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec4,ImGuiColorEditFlags,ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorConvertFloat4ToU32": [
-    {
-      "args": "(const ImVec4 in)",
-      "argsT": [
-        {
-          "name": "in",
-          "type": "const ImVec4"
-        }
-      ],
-      "argsoriginal": "(const ImVec4& in)",
-      "call_args": "(in)",
-      "cimguiname": "igColorConvertFloat4ToU32",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ColorConvertFloat4ToU32",
-      "ret": "ImU32",
-      "signature": "(const ImVec4)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorConvertHSVtoRGB": [
-    {
-      "args": "(float h,float s,float v,float out_r,float out_g,float out_b)",
-      "argsT": [
-        {
-          "name": "h",
-          "type": "float"
-        },
-        {
-          "name": "s",
-          "type": "float"
-        },
-        {
-          "name": "v",
-          "type": "float"
-        },
-        {
-          "name": "out_r",
-          "type": "float&"
-        },
-        {
-          "name": "out_g",
-          "type": "float&"
-        },
-        {
-          "name": "out_b",
-          "type": "float&"
-        }
-      ],
-      "argsoriginal": "(float h,float s,float v,float& out_r,float& out_g,float& out_b)",
-      "call_args": "(h,s,v,out_r,out_g,out_b)",
-      "cimguiname": "igColorConvertHSVtoRGB",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ColorConvertHSVtoRGB",
-      "manual": true,
-      "ret": "void",
-      "signature": "(float,float,float,float,float,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorConvertRGBtoHSV": [
-    {
-      "args": "(float r,float g,float b,float out_h,float out_s,float out_v)",
-      "argsT": [
-        {
-          "name": "r",
-          "type": "float"
-        },
-        {
-          "name": "g",
-          "type": "float"
-        },
-        {
-          "name": "b",
-          "type": "float"
-        },
-        {
-          "name": "out_h",
-          "type": "float&"
-        },
-        {
-          "name": "out_s",
-          "type": "float&"
-        },
-        {
-          "name": "out_v",
-          "type": "float&"
-        }
-      ],
-      "argsoriginal": "(float r,float g,float b,float& out_h,float& out_s,float& out_v)",
-      "call_args": "(r,g,b,out_h,out_s,out_v)",
-      "cimguiname": "igColorConvertRGBtoHSV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ColorConvertRGBtoHSV",
-      "manual": true,
-      "ret": "void",
-      "signature": "(float,float,float,float,float,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorConvertU32ToFloat4": [
-    {
-      "args": "(ImU32 in)",
-      "argsT": [
-        {
-          "name": "in",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImU32 in)",
-      "call_args": "(in)",
-      "cimguiname": "igColorConvertU32ToFloat4",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ColorConvertU32ToFloat4",
-      "ret": "ImVec4",
-      "signature": "(ImU32)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec4 *pOut,ImU32 in)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec4*"
-        },
-        {
-          "name": "in",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImU32 in)",
-      "call_args": "(in)",
-      "cimguiname": "igColorConvertU32ToFloat4",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ColorConvertU32ToFloat4",
-      "nonUDT": 1,
-      "ov_cimguiname": "igColorConvertU32ToFloat4_nonUDT",
-      "ret": "void",
-      "signature": "(ImU32)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImU32 in)",
-      "argsT": [
-        {
-          "name": "in",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImU32 in)",
-      "call_args": "(in)",
-      "cimguiname": "igColorConvertU32ToFloat4",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ColorConvertU32ToFloat4",
-      "nonUDT": 2,
-      "ov_cimguiname": "igColorConvertU32ToFloat4_nonUDT2",
-      "ret": "ImVec4_Simple",
-      "retorig": "ImVec4",
-      "signature": "(ImU32)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorEdit3": [
-    {
-      "args": "(const char* label,float col[3],ImGuiColorEditFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "col",
-          "type": "float[3]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiColorEditFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float col[3],ImGuiColorEditFlags flags=0)",
-      "call_args": "(label,col,flags)",
-      "cimguiname": "igColorEdit3",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "ColorEdit3",
-      "ret": "bool",
-      "signature": "(const char*,float[3],ImGuiColorEditFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorEdit4": [
-    {
-      "args": "(const char* label,float col[4],ImGuiColorEditFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "col",
-          "type": "float[4]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiColorEditFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float col[4],ImGuiColorEditFlags flags=0)",
-      "call_args": "(label,col,flags)",
-      "cimguiname": "igColorEdit4",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "ColorEdit4",
-      "ret": "bool",
-      "signature": "(const char*,float[4],ImGuiColorEditFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorPicker3": [
-    {
-      "args": "(const char* label,float col[3],ImGuiColorEditFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "col",
-          "type": "float[3]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiColorEditFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float col[3],ImGuiColorEditFlags flags=0)",
-      "call_args": "(label,col,flags)",
-      "cimguiname": "igColorPicker3",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "ColorPicker3",
-      "ret": "bool",
-      "signature": "(const char*,float[3],ImGuiColorEditFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColorPicker4": [
-    {
-      "args": "(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "col",
-          "type": "float[4]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiColorEditFlags"
-        },
-        {
-          "name": "ref_col",
-          "type": "const float*"
-        }
-      ],
-      "argsoriginal": "(const char* label,float col[4],ImGuiColorEditFlags flags=0,const float* ref_col=((void*)0))",
-      "call_args": "(label,col,flags,ref_col)",
-      "cimguiname": "igColorPicker4",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "ref_col": "((void*)0)"
-      },
-      "funcname": "ColorPicker4",
-      "ret": "bool",
-      "signature": "(const char*,float[4],ImGuiColorEditFlags,const float*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igColumns": [
-    {
-      "args": "(int count,const char* id,bool border)",
-      "argsT": [
-        {
-          "name": "count",
-          "type": "int"
-        },
-        {
-          "name": "id",
-          "type": "const char*"
-        },
-        {
-          "name": "border",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(int count=1,const char* id=((void*)0),bool border=true)",
-      "call_args": "(count,id,border)",
-      "cimguiname": "igColumns",
-      "comment": "",
-      "defaults": {
-        "border": "true",
-        "count": "1",
-        "id": "((void*)0)"
-      },
-      "funcname": "Columns",
-      "ret": "void",
-      "signature": "(int,const char*,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCombo": [
-    {
-      "args": "(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "current_item",
-          "type": "int*"
-        },
-        {
-          "name": "items",
-          "type": "const char* const[]"
-        },
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "popup_max_height_in_items",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items=-1)",
-      "call_args": "(label,current_item,items,items_count,popup_max_height_in_items)",
-      "cimguiname": "igCombo",
-      "comment": "",
-      "defaults": {
-        "popup_max_height_in_items": "-1"
-      },
-      "funcname": "Combo",
-      "ov_cimguiname": "igCombo",
-      "ret": "bool",
-      "signature": "(const char*,int*,const char* const[],int,int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "current_item",
-          "type": "int*"
-        },
-        {
-          "name": "items_separated_by_zeros",
-          "type": "const char*"
-        },
-        {
-          "name": "popup_max_height_in_items",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items=-1)",
-      "call_args": "(label,current_item,items_separated_by_zeros,popup_max_height_in_items)",
-      "cimguiname": "igCombo",
-      "comment": "",
-      "defaults": {
-        "popup_max_height_in_items": "-1"
-      },
-      "funcname": "Combo",
-      "ov_cimguiname": "igComboStr",
-      "ret": "bool",
-      "signature": "(const char*,int*,const char*,int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "current_item",
-          "type": "int*"
-        },
-        {
-          "name": "items_getter",
-          "ret": "bool",
-          "signature": "(void* data,int idx,const char** out_text)",
-          "type": "bool(*)(void* data,int idx,const char** out_text)"
-        },
-        {
-          "name": "data",
-          "type": "void*"
-        },
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "popup_max_height_in_items",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items=-1)",
-      "call_args": "(label,current_item,items_getter,data,items_count,popup_max_height_in_items)",
-      "cimguiname": "igCombo",
-      "comment": "",
-      "defaults": {
-        "popup_max_height_in_items": "-1"
-      },
-      "funcname": "Combo",
-      "ov_cimguiname": "igComboFnPtr",
-      "ret": "bool",
-      "signature": "(const char*,int*,bool(*)(void*,int,const char**),void*,int,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igCreateContext": [
-    {
-      "args": "(ImFontAtlas* shared_font_atlas)",
-      "argsT": [
-        {
-          "name": "shared_font_atlas",
-          "type": "ImFontAtlas*"
-        }
-      ],
-      "argsoriginal": "(ImFontAtlas* shared_font_atlas=((void*)0))",
-      "call_args": "(shared_font_atlas)",
-      "cimguiname": "igCreateContext",
-      "comment": "",
-      "defaults": {
-        "shared_font_atlas": "((void*)0)"
-      },
-      "funcname": "CreateContext",
-      "ret": "ImGuiContext*",
-      "signature": "(ImFontAtlas*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDebugCheckVersionAndDataLayout": [
-    {
-      "args": "(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert)",
-      "argsT": [
-        {
-          "name": "version_str",
-          "type": "const char*"
-        },
-        {
-          "name": "sz_io",
-          "type": "size_t"
-        },
-        {
-          "name": "sz_style",
-          "type": "size_t"
-        },
-        {
-          "name": "sz_vec2",
-          "type": "size_t"
-        },
-        {
-          "name": "sz_vec4",
-          "type": "size_t"
-        },
-        {
-          "name": "sz_drawvert",
-          "type": "size_t"
-        }
-      ],
-      "argsoriginal": "(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert)",
-      "call_args": "(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert)",
-      "cimguiname": "igDebugCheckVersionAndDataLayout",
-      "comment": "",
-      "defaults": [],
-      "funcname": "DebugCheckVersionAndDataLayout",
-      "ret": "bool",
-      "signature": "(const char*,size_t,size_t,size_t,size_t,size_t)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDestroyContext": [
-    {
-      "args": "(ImGuiContext* ctx)",
-      "argsT": [
-        {
-          "name": "ctx",
-          "type": "ImGuiContext*"
-        }
-      ],
-      "argsoriginal": "(ImGuiContext* ctx=((void*)0))",
-      "call_args": "(ctx)",
-      "cimguiname": "igDestroyContext",
-      "comment": "",
-      "defaults": {
-        "ctx": "((void*)0)"
-      },
-      "funcname": "DestroyContext",
-      "ret": "void",
-      "signature": "(ImGuiContext*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragFloat": [
-    {
-      "args": "(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float*"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float* v,float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_speed,v_min,v_max,format,power)",
-      "cimguiname": "igDragFloat",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f",
-        "v_max": "0.0f",
-        "v_min": "0.0f",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragFloat",
-      "ret": "bool",
-      "signature": "(const char*,float*,float,float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragFloat2": [
-    {
-      "args": "(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[2]"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[2],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_speed,v_min,v_max,format,power)",
-      "cimguiname": "igDragFloat2",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f",
-        "v_max": "0.0f",
-        "v_min": "0.0f",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragFloat2",
-      "ret": "bool",
-      "signature": "(const char*,float[2],float,float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragFloat3": [
-    {
-      "args": "(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[3]"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[3],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_speed,v_min,v_max,format,power)",
-      "cimguiname": "igDragFloat3",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f",
-        "v_max": "0.0f",
-        "v_min": "0.0f",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragFloat3",
-      "ret": "bool",
-      "signature": "(const char*,float[3],float,float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragFloat4": [
-    {
-      "args": "(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[4]"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[4],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_speed,v_min,v_max,format,power)",
-      "cimguiname": "igDragFloat4",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f",
-        "v_max": "0.0f",
-        "v_min": "0.0f",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragFloat4",
-      "ret": "bool",
-      "signature": "(const char*,float[4],float,float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragFloatRange2": [
-    {
-      "args": "(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v_current_min",
-          "type": "float*"
-        },
-        {
-          "name": "v_current_max",
-          "type": "float*"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "format_max",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float* v_current_min,float* v_current_max,float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",const char* format_max=((void*)0),float power=1.0f)",
-      "call_args": "(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power)",
-      "cimguiname": "igDragFloatRange2",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "format_max": "((void*)0)",
-        "power": "1.0f",
-        "v_max": "0.0f",
-        "v_min": "0.0f",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragFloatRange2",
-      "ret": "bool",
-      "signature": "(const char*,float*,float*,float,float,float,const char*,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragInt": [
-    {
-      "args": "(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int*"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* v,float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\")",
-      "call_args": "(label,v,v_speed,v_min,v_max,format)",
-      "cimguiname": "igDragInt",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\"",
-        "v_max": "0",
-        "v_min": "0",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragInt",
-      "ret": "bool",
-      "signature": "(const char*,int*,float,int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragInt2": [
-    {
-      "args": "(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[2]"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[2],float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\")",
-      "call_args": "(label,v,v_speed,v_min,v_max,format)",
-      "cimguiname": "igDragInt2",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\"",
-        "v_max": "0",
-        "v_min": "0",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragInt2",
-      "ret": "bool",
-      "signature": "(const char*,int[2],float,int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragInt3": [
-    {
-      "args": "(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[3]"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[3],float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\")",
-      "call_args": "(label,v,v_speed,v_min,v_max,format)",
-      "cimguiname": "igDragInt3",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\"",
-        "v_max": "0",
-        "v_min": "0",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragInt3",
-      "ret": "bool",
-      "signature": "(const char*,int[3],float,int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragInt4": [
-    {
-      "args": "(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[4]"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[4],float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\")",
-      "call_args": "(label,v,v_speed,v_min,v_max,format)",
-      "cimguiname": "igDragInt4",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\"",
-        "v_max": "0",
-        "v_min": "0",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragInt4",
-      "ret": "bool",
-      "signature": "(const char*,int[4],float,int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragIntRange2": [
-    {
-      "args": "(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v_current_min",
-          "type": "int*"
-        },
-        {
-          "name": "v_current_max",
-          "type": "int*"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "format_max",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* v_current_min,int* v_current_max,float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\",const char* format_max=((void*)0))",
-      "call_args": "(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max)",
-      "cimguiname": "igDragIntRange2",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\"",
-        "format_max": "((void*)0)",
-        "v_max": "0",
-        "v_min": "0",
-        "v_speed": "1.0f"
-      },
-      "funcname": "DragIntRange2",
-      "ret": "bool",
-      "signature": "(const char*,int*,int*,float,int,int,const char*,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragScalar": [
-    {
-      "args": "(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min,const void* v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "const void*"
-        },
-        {
-          "name": "v_max",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min=((void*)0),const void* v_max=((void*)0),const char* format=((void*)0),float power=1.0f)",
-      "call_args": "(label,data_type,v,v_speed,v_min,v_max,format,power)",
-      "cimguiname": "igDragScalar",
-      "comment": "",
-      "defaults": {
-        "format": "((void*)0)",
-        "power": "1.0f",
-        "v_max": "((void*)0)",
-        "v_min": "((void*)0)"
-      },
-      "funcname": "DragScalar",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDataType,void*,float,const void*,const void*,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDragScalarN": [
-    {
-      "args": "(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min,const void* v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "components",
-          "type": "int"
-        },
-        {
-          "name": "v_speed",
-          "type": "float"
-        },
-        {
-          "name": "v_min",
-          "type": "const void*"
-        },
-        {
-          "name": "v_max",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min=((void*)0),const void* v_max=((void*)0),const char* format=((void*)0),float power=1.0f)",
-      "call_args": "(label,data_type,v,components,v_speed,v_min,v_max,format,power)",
-      "cimguiname": "igDragScalarN",
-      "comment": "",
-      "defaults": {
-        "format": "((void*)0)",
-        "power": "1.0f",
-        "v_max": "((void*)0)",
-        "v_min": "((void*)0)"
-      },
-      "funcname": "DragScalarN",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDataType,void*,int,float,const void*,const void*,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igDummy": [
-    {
-      "args": "(const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& size)",
-      "call_args": "(size)",
-      "cimguiname": "igDummy",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Dummy",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igEnd": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEnd",
-      "comment": "",
-      "defaults": [],
-      "funcname": "End",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndChild": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndChild",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndChild",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndChildFrame": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndChildFrame",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndChildFrame",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndCombo": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndCombo",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndCombo",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndDragDropSource": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndDragDropSource",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndDragDropSource",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndDragDropTarget": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndDragDropTarget",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndDragDropTarget",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndFrame": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndFrame",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndFrame",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndGroup": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndGroup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndGroup",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndMainMenuBar": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndMainMenuBar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndMainMenuBar",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndMenu": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndMenu",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndMenu",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndMenuBar": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndMenuBar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndMenuBar",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndPopup": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndPopup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndPopup",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndTabBar": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndTabBar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndTabBar",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndTabItem": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndTabItem",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndTabItem",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igEndTooltip": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igEndTooltip",
-      "comment": "",
-      "defaults": [],
-      "funcname": "EndTooltip",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetClipboardText": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetClipboardText",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetClipboardText",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetColorU32": [
-    {
-      "args": "(ImGuiCol idx,float alpha_mul)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiCol"
-        },
-        {
-          "name": "alpha_mul",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImGuiCol idx,float alpha_mul=1.0f)",
-      "call_args": "(idx,alpha_mul)",
-      "cimguiname": "igGetColorU32",
-      "comment": "",
-      "defaults": {
-        "alpha_mul": "1.0f"
-      },
-      "funcname": "GetColorU32",
-      "ov_cimguiname": "igGetColorU32",
-      "ret": "ImU32",
-      "signature": "(ImGuiCol,float)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const ImVec4 col)",
-      "argsT": [
-        {
-          "name": "col",
-          "type": "const ImVec4"
-        }
-      ],
-      "argsoriginal": "(const ImVec4& col)",
-      "call_args": "(col)",
-      "cimguiname": "igGetColorU32",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetColorU32",
-      "ov_cimguiname": "igGetColorU32Vec4",
-      "ret": "ImU32",
-      "signature": "(const ImVec4)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImU32 col)",
-      "argsT": [
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImU32 col)",
-      "call_args": "(col)",
-      "cimguiname": "igGetColorU32",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetColorU32",
-      "ov_cimguiname": "igGetColorU32U32",
-      "ret": "ImU32",
-      "signature": "(ImU32)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetColumnIndex": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetColumnIndex",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetColumnIndex",
-      "ret": "int",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetColumnOffset": [
-    {
-      "args": "(int column_index)",
-      "argsT": [
-        {
-          "name": "column_index",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int column_index=-1)",
-      "call_args": "(column_index)",
-      "cimguiname": "igGetColumnOffset",
-      "comment": "",
-      "defaults": {
-        "column_index": "-1"
-      },
-      "funcname": "GetColumnOffset",
-      "ret": "float",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetColumnWidth": [
-    {
-      "args": "(int column_index)",
-      "argsT": [
-        {
-          "name": "column_index",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int column_index=-1)",
-      "call_args": "(column_index)",
-      "cimguiname": "igGetColumnWidth",
-      "comment": "",
-      "defaults": {
-        "column_index": "-1"
-      },
-      "funcname": "GetColumnWidth",
-      "ret": "float",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetColumnsCount": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetColumnsCount",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetColumnsCount",
-      "ret": "int",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetContentRegionAvail": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionAvail",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionAvail",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionAvail",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionAvail",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetContentRegionAvail_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionAvail",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionAvail",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetContentRegionAvail_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetContentRegionAvailWidth": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionAvailWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionAvailWidth",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetContentRegionMax": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionMax",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionMax",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetContentRegionMax_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetContentRegionMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetContentRegionMax",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetContentRegionMax_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetCurrentContext": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCurrentContext",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCurrentContext",
-      "ret": "ImGuiContext*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetCursorPos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorPos",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorPos",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetCursorPos_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorPos",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetCursorPos_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetCursorPosX": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorPosX",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorPosX",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetCursorPosY": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorPosY",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorPosY",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetCursorScreenPos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorScreenPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorScreenPos",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorScreenPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorScreenPos",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetCursorScreenPos_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorScreenPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorScreenPos",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetCursorScreenPos_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetCursorStartPos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorStartPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorStartPos",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorStartPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorStartPos",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetCursorStartPos_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetCursorStartPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetCursorStartPos",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetCursorStartPos_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetDragDropPayload": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetDragDropPayload",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetDragDropPayload",
-      "ret": "const ImGuiPayload*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetDrawData": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetDrawData",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetDrawData",
-      "ret": "ImDrawData*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetDrawListSharedData": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetDrawListSharedData",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetDrawListSharedData",
-      "ret": "ImDrawListSharedData*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetFont": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFont",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFont",
-      "ret": "ImFont*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetFontSize": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFontSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFontSize",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetFontTexUvWhitePixel": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFontTexUvWhitePixel",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFontTexUvWhitePixel",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFontTexUvWhitePixel",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFontTexUvWhitePixel",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetFontTexUvWhitePixel_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFontTexUvWhitePixel",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFontTexUvWhitePixel",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetFontTexUvWhitePixel_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetFrameCount": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFrameCount",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFrameCount",
-      "ret": "int",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetFrameHeight": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFrameHeight",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFrameHeight",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetFrameHeightWithSpacing": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetFrameHeightWithSpacing",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetFrameHeightWithSpacing",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetID": [
-    {
-      "args": "(const char* str_id)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id)",
-      "call_args": "(str_id)",
-      "cimguiname": "igGetID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetID",
-      "ov_cimguiname": "igGetIDStr",
-      "ret": "ImGuiID",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* str_id_begin,const char* str_id_end)",
-      "argsT": [
-        {
-          "name": "str_id_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "str_id_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id_begin,const char* str_id_end)",
-      "call_args": "(str_id_begin,str_id_end)",
-      "cimguiname": "igGetID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetID",
-      "ov_cimguiname": "igGetIDRange",
-      "ret": "ImGuiID",
-      "signature": "(const char*,const char*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id)",
-      "call_args": "(ptr_id)",
-      "cimguiname": "igGetID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetID",
-      "ov_cimguiname": "igGetIDPtr",
-      "ret": "ImGuiID",
-      "signature": "(const void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetIO": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetIO",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetIO",
-      "ret": "ImGuiIO*",
-      "retref": "&",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetItemRectMax": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectMax",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectMax",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetItemRectMax_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectMax",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetItemRectMax_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetItemRectMin": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectMin",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectMin",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetItemRectMin_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectMin",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetItemRectMin_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetItemRectSize": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectSize",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectSize",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetItemRectSize_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetItemRectSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetItemRectSize",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetItemRectSize_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetKeyIndex": [
-    {
-      "args": "(ImGuiKey imgui_key)",
-      "argsT": [
-        {
-          "name": "imgui_key",
-          "type": "ImGuiKey"
-        }
-      ],
-      "argsoriginal": "(ImGuiKey imgui_key)",
-      "call_args": "(imgui_key)",
-      "cimguiname": "igGetKeyIndex",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetKeyIndex",
-      "ret": "int",
-      "signature": "(ImGuiKey)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetKeyPressedAmount": [
-    {
-      "args": "(int key_index,float repeat_delay,float rate)",
-      "argsT": [
-        {
-          "name": "key_index",
-          "type": "int"
-        },
-        {
-          "name": "repeat_delay",
-          "type": "float"
-        },
-        {
-          "name": "rate",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int key_index,float repeat_delay,float rate)",
-      "call_args": "(key_index,repeat_delay,rate)",
-      "cimguiname": "igGetKeyPressedAmount",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetKeyPressedAmount",
-      "ret": "int",
-      "signature": "(int,float,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetMouseCursor": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMouseCursor",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMouseCursor",
-      "ret": "ImGuiMouseCursor",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetMouseDragDelta": [
-    {
-      "args": "(int button,float lock_threshold)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        },
-        {
-          "name": "lock_threshold",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int button=0,float lock_threshold=-1.0f)",
-      "call_args": "(button,lock_threshold)",
-      "cimguiname": "igGetMouseDragDelta",
-      "comment": "",
-      "defaults": {
-        "button": "0",
-        "lock_threshold": "-1.0f"
-      },
-      "funcname": "GetMouseDragDelta",
-      "ret": "ImVec2",
-      "signature": "(int,float)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut,int button,float lock_threshold)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        },
-        {
-          "name": "button",
-          "type": "int"
-        },
-        {
-          "name": "lock_threshold",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int button=0,float lock_threshold=-1.0f)",
-      "call_args": "(button,lock_threshold)",
-      "cimguiname": "igGetMouseDragDelta",
-      "comment": "",
-      "defaults": {
-        "button": "0",
-        "lock_threshold": "-1.0f"
-      },
-      "funcname": "GetMouseDragDelta",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetMouseDragDelta_nonUDT",
-      "ret": "void",
-      "signature": "(int,float)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(int button,float lock_threshold)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        },
-        {
-          "name": "lock_threshold",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int button=0,float lock_threshold=-1.0f)",
-      "call_args": "(button,lock_threshold)",
-      "cimguiname": "igGetMouseDragDelta",
-      "comment": "",
-      "defaults": {
-        "button": "0",
-        "lock_threshold": "-1.0f"
-      },
-      "funcname": "GetMouseDragDelta",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetMouseDragDelta_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "(int,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetMousePos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMousePos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMousePos",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMousePos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMousePos",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetMousePos_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMousePos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMousePos",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetMousePos_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetMousePosOnOpeningCurrentPopup": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMousePosOnOpeningCurrentPopup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMousePosOnOpeningCurrentPopup",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMousePosOnOpeningCurrentPopup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMousePosOnOpeningCurrentPopup",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetMousePosOnOpeningCurrentPopup_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetMousePosOnOpeningCurrentPopup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetMousePosOnOpeningCurrentPopup",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetMousePosOnOpeningCurrentPopup_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetOverlayDrawList": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetOverlayDrawList",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetOverlayDrawList",
-      "ret": "ImDrawList*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetScrollMaxX": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetScrollMaxX",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetScrollMaxX",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetScrollMaxY": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetScrollMaxY",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetScrollMaxY",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetScrollX": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetScrollX",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetScrollX",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetScrollY": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetScrollY",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetScrollY",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetStateStorage": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetStateStorage",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetStateStorage",
-      "ret": "ImGuiStorage*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetStyle": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetStyle",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetStyle",
-      "ret": "ImGuiStyle*",
-      "retref": "&",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetStyleColorName": [
-    {
-      "args": "(ImGuiCol idx)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiCol"
-        }
-      ],
-      "argsoriginal": "(ImGuiCol idx)",
-      "call_args": "(idx)",
-      "cimguiname": "igGetStyleColorName",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetStyleColorName",
-      "ret": "const char*",
-      "signature": "(ImGuiCol)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetStyleColorVec4": [
-    {
-      "args": "(ImGuiCol idx)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiCol"
-        }
-      ],
-      "argsoriginal": "(ImGuiCol idx)",
-      "call_args": "(idx)",
-      "cimguiname": "igGetStyleColorVec4",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetStyleColorVec4",
-      "ret": "const ImVec4*",
-      "retref": "&",
-      "signature": "(ImGuiCol)",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetTextLineHeight": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetTextLineHeight",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetTextLineHeight",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetTextLineHeightWithSpacing": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetTextLineHeightWithSpacing",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetTextLineHeightWithSpacing",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetTime": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetTime",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetTime",
-      "ret": "double",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetTreeNodeToLabelSpacing": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetTreeNodeToLabelSpacing",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetTreeNodeToLabelSpacing",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetVersion": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetVersion",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetVersion",
-      "ret": "const char*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowContentRegionMax": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionMax",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionMax",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetWindowContentRegionMax_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionMax",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionMax",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetWindowContentRegionMax_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowContentRegionMin": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionMin",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionMin",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetWindowContentRegionMin_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionMin",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionMin",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetWindowContentRegionMin_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowContentRegionWidth": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowContentRegionWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowContentRegionWidth",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowDrawList": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowDrawList",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowDrawList",
-      "ret": "ImDrawList*",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowHeight": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowHeight",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowHeight",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowPos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowPos",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowPos",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetWindowPos_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowPos",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetWindowPos_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowSize": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowSize",
-      "ret": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImVec2 *pOut)",
-      "argsT": [
-        {
-          "name": "pOut",
-          "type": "ImVec2*"
-        }
-      ],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowSize",
-      "nonUDT": 1,
-      "ov_cimguiname": "igGetWindowSize_nonUDT",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowSize",
-      "nonUDT": 2,
-      "ov_cimguiname": "igGetWindowSize_nonUDT2",
-      "ret": "ImVec2_Simple",
-      "retorig": "ImVec2",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igGetWindowWidth": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igGetWindowWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "GetWindowWidth",
-      "ret": "float",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igImage": [
-    {
-      "args": "(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)",
-      "argsT": [
-        {
-          "name": "user_texture_id",
-          "type": "ImTextureID"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv0",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv1",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "tint_col",
-          "type": "const ImVec4"
-        },
-        {
-          "name": "border_col",
-          "type": "const ImVec4"
-        }
-      ],
-      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& size,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),const ImVec4& tint_col=ImVec4(1,1,1,1),const ImVec4& border_col=ImVec4(0,0,0,0))",
-      "call_args": "(user_texture_id,size,uv0,uv1,tint_col,border_col)",
-      "cimguiname": "igImage",
-      "comment": "",
-      "defaults": {
-        "border_col": "ImVec4(0,0,0,0)",
-        "tint_col": "ImVec4(1,1,1,1)",
-        "uv0": "ImVec2(0,0)",
-        "uv1": "ImVec2(1,1)"
-      },
-      "funcname": "Image",
-      "ret": "void",
-      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec4,const ImVec4)",
-      "stname": "ImGui"
-    }
-  ],
-  "igImageButton": [
-    {
-      "args": "(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col)",
-      "argsT": [
-        {
-          "name": "user_texture_id",
-          "type": "ImTextureID"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv0",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "uv1",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "frame_padding",
-          "type": "int"
-        },
-        {
-          "name": "bg_col",
-          "type": "const ImVec4"
-        },
-        {
-          "name": "tint_col",
-          "type": "const ImVec4"
-        }
-      ],
-      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& size,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),int frame_padding=-1,const ImVec4& bg_col=ImVec4(0,0,0,0),const ImVec4& tint_col=ImVec4(1,1,1,1))",
-      "call_args": "(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col)",
-      "cimguiname": "igImageButton",
-      "comment": "",
-      "defaults": {
-        "bg_col": "ImVec4(0,0,0,0)",
-        "frame_padding": "-1",
-        "tint_col": "ImVec4(1,1,1,1)",
-        "uv0": "ImVec2(0,0)",
-        "uv1": "ImVec2(1,1)"
-      },
-      "funcname": "ImageButton",
-      "ret": "bool",
-      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,int,const ImVec4,const ImVec4)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIndent": [
-    {
-      "args": "(float indent_w)",
-      "argsT": [
-        {
-          "name": "indent_w",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float indent_w=0.0f)",
-      "call_args": "(indent_w)",
-      "cimguiname": "igIndent",
-      "comment": "",
-      "defaults": {
-        "indent_w": "0.0f"
-      },
-      "funcname": "Indent",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputDouble": [
-    {
-      "args": "(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "double*"
-        },
-        {
-          "name": "step",
-          "type": "double"
-        },
-        {
-          "name": "step_fast",
-          "type": "double"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,double* v,double step=0.0,double step_fast=0.0,const char* format=\"%.6f\",ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,step,step_fast,format,flags)",
-      "cimguiname": "igInputDouble",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "\"%.6f\"",
-        "step": "0.0",
-        "step_fast": "0.0"
-      },
-      "funcname": "InputDouble",
-      "ret": "bool",
-      "signature": "(const char*,double*,double,double,const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputFloat": [
-    {
-      "args": "(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float*"
-        },
-        {
-          "name": "step",
-          "type": "float"
-        },
-        {
-          "name": "step_fast",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float* v,float step=0.0f,float step_fast=0.0f,const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,step,step_fast,format,flags)",
-      "cimguiname": "igInputFloat",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "\"%.3f\"",
-        "step": "0.0f",
-        "step_fast": "0.0f"
-      },
-      "funcname": "InputFloat",
-      "ret": "bool",
-      "signature": "(const char*,float*,float,float,const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputFloat2": [
-    {
-      "args": "(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[2]"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[2],const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,format,flags)",
-      "cimguiname": "igInputFloat2",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "\"%.3f\""
-      },
-      "funcname": "InputFloat2",
-      "ret": "bool",
-      "signature": "(const char*,float[2],const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputFloat3": [
-    {
-      "args": "(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[3]"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[3],const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,format,flags)",
-      "cimguiname": "igInputFloat3",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "\"%.3f\""
-      },
-      "funcname": "InputFloat3",
-      "ret": "bool",
-      "signature": "(const char*,float[3],const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputFloat4": [
-    {
-      "args": "(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[4]"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[4],const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,format,flags)",
-      "cimguiname": "igInputFloat4",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "\"%.3f\""
-      },
-      "funcname": "InputFloat4",
-      "ret": "bool",
-      "signature": "(const char*,float[4],const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputInt": [
-    {
-      "args": "(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int*"
-        },
-        {
-          "name": "step",
-          "type": "int"
-        },
-        {
-          "name": "step_fast",
-          "type": "int"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* v,int step=1,int step_fast=100,ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,step,step_fast,flags)",
-      "cimguiname": "igInputInt",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "step": "1",
-        "step_fast": "100"
-      },
-      "funcname": "InputInt",
-      "ret": "bool",
-      "signature": "(const char*,int*,int,int,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputInt2": [
-    {
-      "args": "(const char* label,int v[2],ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[2]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[2],ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,flags)",
-      "cimguiname": "igInputInt2",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "InputInt2",
-      "ret": "bool",
-      "signature": "(const char*,int[2],ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputInt3": [
-    {
-      "args": "(const char* label,int v[3],ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[3]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[3],ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,flags)",
-      "cimguiname": "igInputInt3",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "InputInt3",
-      "ret": "bool",
-      "signature": "(const char*,int[3],ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputInt4": [
-    {
-      "args": "(const char* label,int v[4],ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[4]"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[4],ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,v,flags)",
-      "cimguiname": "igInputInt4",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "InputInt4",
-      "ret": "bool",
-      "signature": "(const char*,int[4],ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputScalar": [
-    {
-      "args": "(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "step",
-          "type": "const void*"
-        },
-        {
-          "name": "step_fast",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* v,const void* step=((void*)0),const void* step_fast=((void*)0),const char* format=((void*)0),ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,data_type,v,step,step_fast,format,flags)",
-      "cimguiname": "igInputScalar",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "((void*)0)",
-        "step": "((void*)0)",
-        "step_fast": "((void*)0)"
-      },
-      "funcname": "InputScalar",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDataType,void*,const void*,const void*,const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputScalarN": [
-    {
-      "args": "(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "components",
-          "type": "int"
-        },
-        {
-          "name": "step",
-          "type": "const void*"
-        },
-        {
-          "name": "step_fast",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* v,int components,const void* step=((void*)0),const void* step_fast=((void*)0),const char* format=((void*)0),ImGuiInputTextFlags flags=0)",
-      "call_args": "(label,data_type,v,components,step,step_fast,format,flags)",
-      "cimguiname": "igInputScalarN",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "format": "((void*)0)",
-        "step": "((void*)0)",
-        "step_fast": "((void*)0)"
-      },
-      "funcname": "InputScalarN",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDataType,void*,int,const void*,const void*,const char*,ImGuiInputTextFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputText": [
-    {
-      "args": "(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "buf",
-          "type": "char*"
-        },
-        {
-          "name": "buf_size",
-          "type": "size_t"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        },
-        {
-          "name": "callback",
-          "type": "ImGuiInputTextCallback"
-        },
-        {
-          "name": "user_data",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags=0,ImGuiInputTextCallback callback=((void*)0),void* user_data=((void*)0))",
-      "call_args": "(label,buf,buf_size,flags,callback,user_data)",
-      "cimguiname": "igInputText",
-      "comment": "",
-      "defaults": {
-        "callback": "((void*)0)",
-        "flags": "0",
-        "user_data": "((void*)0)"
-      },
-      "funcname": "InputText",
-      "ret": "bool",
-      "signature": "(const char*,char*,size_t,ImGuiInputTextFlags,ImGuiInputTextCallback,void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInputTextMultiline": [
-    {
-      "args": "(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "buf",
-          "type": "char*"
-        },
-        {
-          "name": "buf_size",
-          "type": "size_t"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiInputTextFlags"
-        },
-        {
-          "name": "callback",
-          "type": "ImGuiInputTextCallback"
-        },
-        {
-          "name": "user_data",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(const char* label,char* buf,size_t buf_size,const ImVec2& size=ImVec2(0,0),ImGuiInputTextFlags flags=0,ImGuiInputTextCallback callback=((void*)0),void* user_data=((void*)0))",
-      "call_args": "(label,buf,buf_size,size,flags,callback,user_data)",
-      "cimguiname": "igInputTextMultiline",
-      "comment": "",
-      "defaults": {
-        "callback": "((void*)0)",
-        "flags": "0",
-        "size": "ImVec2(0,0)",
-        "user_data": "((void*)0)"
-      },
-      "funcname": "InputTextMultiline",
-      "ret": "bool",
-      "signature": "(const char*,char*,size_t,const ImVec2,ImGuiInputTextFlags,ImGuiInputTextCallback,void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igInvisibleButton": [
-    {
-      "args": "(const char* str_id,const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,const ImVec2& size)",
-      "call_args": "(str_id,size)",
-      "cimguiname": "igInvisibleButton",
-      "comment": "",
-      "defaults": [],
-      "funcname": "InvisibleButton",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsAnyItemActive": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsAnyItemActive",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsAnyItemActive",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsAnyItemFocused": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsAnyItemFocused",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsAnyItemFocused",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsAnyItemHovered": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsAnyItemHovered",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsAnyItemHovered",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsAnyMouseDown": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsAnyMouseDown",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsAnyMouseDown",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemActive": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsItemActive",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsItemActive",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemClicked": [
-    {
-      "args": "(int mouse_button)",
-      "argsT": [
-        {
-          "name": "mouse_button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int mouse_button=0)",
-      "call_args": "(mouse_button)",
-      "cimguiname": "igIsItemClicked",
-      "comment": "",
-      "defaults": {
-        "mouse_button": "0"
-      },
-      "funcname": "IsItemClicked",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemDeactivated": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsItemDeactivated",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsItemDeactivated",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemDeactivatedAfterEdit": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsItemDeactivatedAfterEdit",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsItemDeactivatedAfterEdit",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemEdited": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsItemEdited",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsItemEdited",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemFocused": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsItemFocused",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsItemFocused",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemHovered": [
-    {
-      "args": "(ImGuiHoveredFlags flags)",
-      "argsT": [
-        {
-          "name": "flags",
-          "type": "ImGuiHoveredFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiHoveredFlags flags=0)",
-      "call_args": "(flags)",
-      "cimguiname": "igIsItemHovered",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "IsItemHovered",
-      "ret": "bool",
-      "signature": "(ImGuiHoveredFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsItemVisible": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsItemVisible",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsItemVisible",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsKeyDown": [
-    {
-      "args": "(int user_key_index)",
-      "argsT": [
-        {
-          "name": "user_key_index",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int user_key_index)",
-      "call_args": "(user_key_index)",
-      "cimguiname": "igIsKeyDown",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsKeyDown",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsKeyPressed": [
-    {
-      "args": "(int user_key_index,bool repeat)",
-      "argsT": [
-        {
-          "name": "user_key_index",
-          "type": "int"
-        },
-        {
-          "name": "repeat",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(int user_key_index,bool repeat=true)",
-      "call_args": "(user_key_index,repeat)",
-      "cimguiname": "igIsKeyPressed",
-      "comment": "",
-      "defaults": {
-        "repeat": "true"
-      },
-      "funcname": "IsKeyPressed",
-      "ret": "bool",
-      "signature": "(int,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsKeyReleased": [
-    {
-      "args": "(int user_key_index)",
-      "argsT": [
-        {
-          "name": "user_key_index",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int user_key_index)",
-      "call_args": "(user_key_index)",
-      "cimguiname": "igIsKeyReleased",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsKeyReleased",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMouseClicked": [
-    {
-      "args": "(int button,bool repeat)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        },
-        {
-          "name": "repeat",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(int button,bool repeat=false)",
-      "call_args": "(button,repeat)",
-      "cimguiname": "igIsMouseClicked",
-      "comment": "",
-      "defaults": {
-        "repeat": "false"
-      },
-      "funcname": "IsMouseClicked",
-      "ret": "bool",
-      "signature": "(int,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMouseDoubleClicked": [
-    {
-      "args": "(int button)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int button)",
-      "call_args": "(button)",
-      "cimguiname": "igIsMouseDoubleClicked",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsMouseDoubleClicked",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMouseDown": [
-    {
-      "args": "(int button)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int button)",
-      "call_args": "(button)",
-      "cimguiname": "igIsMouseDown",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsMouseDown",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMouseDragging": [
-    {
-      "args": "(int button,float lock_threshold)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        },
-        {
-          "name": "lock_threshold",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int button=0,float lock_threshold=-1.0f)",
-      "call_args": "(button,lock_threshold)",
-      "cimguiname": "igIsMouseDragging",
-      "comment": "",
-      "defaults": {
-        "button": "0",
-        "lock_threshold": "-1.0f"
-      },
-      "funcname": "IsMouseDragging",
-      "ret": "bool",
-      "signature": "(int,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMouseHoveringRect": [
-    {
-      "args": "(const ImVec2 r_min,const ImVec2 r_max,bool clip)",
-      "argsT": [
-        {
-          "name": "r_min",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "r_max",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "clip",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& r_min,const ImVec2& r_max,bool clip=true)",
-      "call_args": "(r_min,r_max,clip)",
-      "cimguiname": "igIsMouseHoveringRect",
-      "comment": "",
-      "defaults": {
-        "clip": "true"
-      },
-      "funcname": "IsMouseHoveringRect",
-      "ret": "bool",
-      "signature": "(const ImVec2,const ImVec2,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMousePosValid": [
-    {
-      "args": "(const ImVec2* mouse_pos)",
-      "argsT": [
-        {
-          "name": "mouse_pos",
-          "type": "const ImVec2*"
-        }
-      ],
-      "argsoriginal": "(const ImVec2* mouse_pos=((void*)0))",
-      "call_args": "(mouse_pos)",
-      "cimguiname": "igIsMousePosValid",
-      "comment": "",
-      "defaults": {
-        "mouse_pos": "((void*)0)"
-      },
-      "funcname": "IsMousePosValid",
-      "ret": "bool",
-      "signature": "(const ImVec2*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsMouseReleased": [
-    {
-      "args": "(int button)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int button)",
-      "call_args": "(button)",
-      "cimguiname": "igIsMouseReleased",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsMouseReleased",
-      "ret": "bool",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsPopupOpen": [
-    {
-      "args": "(const char* str_id)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id)",
-      "call_args": "(str_id)",
-      "cimguiname": "igIsPopupOpen",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsPopupOpen",
-      "ret": "bool",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsRectVisible": [
-    {
-      "args": "(const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& size)",
-      "call_args": "(size)",
-      "cimguiname": "igIsRectVisible",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsRectVisible",
-      "ov_cimguiname": "igIsRectVisible",
-      "ret": "bool",
-      "signature": "(const ImVec2)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const ImVec2 rect_min,const ImVec2 rect_max)",
-      "argsT": [
-        {
-          "name": "rect_min",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "rect_max",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& rect_min,const ImVec2& rect_max)",
-      "call_args": "(rect_min,rect_max)",
-      "cimguiname": "igIsRectVisible",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsRectVisible",
-      "ov_cimguiname": "igIsRectVisibleVec2",
-      "ret": "bool",
-      "signature": "(const ImVec2,const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsWindowAppearing": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsWindowAppearing",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsWindowAppearing",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsWindowCollapsed": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igIsWindowCollapsed",
-      "comment": "",
-      "defaults": [],
-      "funcname": "IsWindowCollapsed",
-      "ret": "bool",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsWindowFocused": [
-    {
-      "args": "(ImGuiFocusedFlags flags)",
-      "argsT": [
-        {
-          "name": "flags",
-          "type": "ImGuiFocusedFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiFocusedFlags flags=0)",
-      "call_args": "(flags)",
-      "cimguiname": "igIsWindowFocused",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "IsWindowFocused",
-      "ret": "bool",
-      "signature": "(ImGuiFocusedFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igIsWindowHovered": [
-    {
-      "args": "(ImGuiHoveredFlags flags)",
-      "argsT": [
-        {
-          "name": "flags",
-          "type": "ImGuiHoveredFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiHoveredFlags flags=0)",
-      "call_args": "(flags)",
-      "cimguiname": "igIsWindowHovered",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "IsWindowHovered",
-      "ret": "bool",
-      "signature": "(ImGuiHoveredFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLabelText": [
-    {
-      "args": "(const char* label,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* label,const char* fmt,...)",
-      "call_args": "(label,fmt,...)",
-      "cimguiname": "igLabelText",
-      "comment": "",
-      "defaults": [],
-      "funcname": "LabelText",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const char*,const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLabelTextV": [
-    {
-      "args": "(const char* label,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* label,const char* fmt,va_list args)",
-      "call_args": "(label,fmt,args)",
-      "cimguiname": "igLabelTextV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "LabelTextV",
-      "ret": "void",
-      "signature": "(const char*,const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igListBox": [
-    {
-      "args": "(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "current_item",
-          "type": "int*"
-        },
-        {
-          "name": "items",
-          "type": "const char* const[]"
-        },
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "height_in_items",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items=-1)",
-      "call_args": "(label,current_item,items,items_count,height_in_items)",
-      "cimguiname": "igListBox",
-      "comment": "",
-      "defaults": {
-        "height_in_items": "-1"
-      },
-      "funcname": "ListBox",
-      "ov_cimguiname": "igListBoxStr_arr",
-      "ret": "bool",
-      "signature": "(const char*,int*,const char* const[],int,int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "current_item",
-          "type": "int*"
-        },
-        {
-          "name": "items_getter",
-          "ret": "bool",
-          "signature": "(void* data,int idx,const char** out_text)",
-          "type": "bool(*)(void* data,int idx,const char** out_text)"
-        },
-        {
-          "name": "data",
-          "type": "void*"
-        },
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "height_in_items",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* current_item,bool(*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items=-1)",
-      "call_args": "(label,current_item,items_getter,data,items_count,height_in_items)",
-      "cimguiname": "igListBox",
-      "comment": "",
-      "defaults": {
-        "height_in_items": "-1"
-      },
-      "funcname": "ListBox",
-      "ov_cimguiname": "igListBoxFnPtr",
-      "ret": "bool",
-      "signature": "(const char*,int*,bool(*)(void*,int,const char**),void*,int,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igListBoxFooter": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igListBoxFooter",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ListBoxFooter",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igListBoxHeader": [
-    {
-      "args": "(const char* label,const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* label,const ImVec2& size=ImVec2(0,0))",
-      "call_args": "(label,size)",
-      "cimguiname": "igListBoxHeader",
-      "comment": "",
-      "defaults": {
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "ListBoxHeader",
-      "ov_cimguiname": "igListBoxHeaderVec2",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,int items_count,int height_in_items)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "items_count",
-          "type": "int"
-        },
-        {
-          "name": "height_in_items",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int items_count,int height_in_items=-1)",
-      "call_args": "(label,items_count,height_in_items)",
-      "cimguiname": "igListBoxHeader",
-      "comment": "",
-      "defaults": {
-        "height_in_items": "-1"
-      },
-      "funcname": "ListBoxHeader",
-      "ov_cimguiname": "igListBoxHeaderInt",
-      "ret": "bool",
-      "signature": "(const char*,int,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLoadIniSettingsFromDisk": [
-    {
-      "args": "(const char* ini_filename)",
-      "argsT": [
-        {
-          "name": "ini_filename",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* ini_filename)",
-      "call_args": "(ini_filename)",
-      "cimguiname": "igLoadIniSettingsFromDisk",
-      "comment": "",
-      "defaults": [],
-      "funcname": "LoadIniSettingsFromDisk",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLoadIniSettingsFromMemory": [
-    {
-      "args": "(const char* ini_data,size_t ini_size)",
-      "argsT": [
-        {
-          "name": "ini_data",
-          "type": "const char*"
-        },
-        {
-          "name": "ini_size",
-          "type": "size_t"
-        }
-      ],
-      "argsoriginal": "(const char* ini_data,size_t ini_size=0)",
-      "call_args": "(ini_data,ini_size)",
-      "cimguiname": "igLoadIniSettingsFromMemory",
-      "comment": "",
-      "defaults": {
-        "ini_size": "0"
-      },
-      "funcname": "LoadIniSettingsFromMemory",
-      "ret": "void",
-      "signature": "(const char*,size_t)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLogButtons": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igLogButtons",
-      "comment": "",
-      "defaults": [],
-      "funcname": "LogButtons",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igLogFinish": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igLogFinish",
-      "comment": "",
-      "defaults": [],
-      "funcname": "LogFinish",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igLogText": [
-    {
-      "args": "(const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "igLogText",
-      "comment": "",
-      "defaults": [],
-      "funcname": "LogText",
-      "isvararg": "...)",
-      "manual": true,
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLogToClipboard": [
-    {
-      "args": "(int max_depth)",
-      "argsT": [
-        {
-          "name": "max_depth",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int max_depth=-1)",
-      "call_args": "(max_depth)",
-      "cimguiname": "igLogToClipboard",
-      "comment": "",
-      "defaults": {
-        "max_depth": "-1"
-      },
-      "funcname": "LogToClipboard",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLogToFile": [
-    {
-      "args": "(int max_depth,const char* filename)",
-      "argsT": [
-        {
-          "name": "max_depth",
-          "type": "int"
-        },
-        {
-          "name": "filename",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(int max_depth=-1,const char* filename=((void*)0))",
-      "call_args": "(max_depth,filename)",
-      "cimguiname": "igLogToFile",
-      "comment": "",
-      "defaults": {
-        "filename": "((void*)0)",
-        "max_depth": "-1"
-      },
-      "funcname": "LogToFile",
-      "ret": "void",
-      "signature": "(int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igLogToTTY": [
-    {
-      "args": "(int max_depth)",
-      "argsT": [
-        {
-          "name": "max_depth",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int max_depth=-1)",
-      "call_args": "(max_depth)",
-      "cimguiname": "igLogToTTY",
-      "comment": "",
-      "defaults": {
-        "max_depth": "-1"
-      },
-      "funcname": "LogToTTY",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igMemAlloc": [
-    {
-      "args": "(size_t size)",
-      "argsT": [
-        {
-          "name": "size",
-          "type": "size_t"
-        }
-      ],
-      "argsoriginal": "(size_t size)",
-      "call_args": "(size)",
-      "cimguiname": "igMemAlloc",
-      "comment": "",
-      "defaults": [],
-      "funcname": "MemAlloc",
-      "ret": "void*",
-      "signature": "(size_t)",
-      "stname": "ImGui"
-    }
-  ],
-  "igMemFree": [
-    {
-      "args": "(void* ptr)",
-      "argsT": [
-        {
-          "name": "ptr",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(void* ptr)",
-      "call_args": "(ptr)",
-      "cimguiname": "igMemFree",
-      "comment": "",
-      "defaults": [],
-      "funcname": "MemFree",
-      "ret": "void",
-      "signature": "(void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igMenuItem": [
-    {
-      "args": "(const char* label,const char* shortcut,bool selected,bool enabled)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "shortcut",
-          "type": "const char*"
-        },
-        {
-          "name": "selected",
-          "type": "bool"
-        },
-        {
-          "name": "enabled",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const char* label,const char* shortcut=((void*)0),bool selected=false,bool enabled=true)",
-      "call_args": "(label,shortcut,selected,enabled)",
-      "cimguiname": "igMenuItem",
-      "comment": "",
-      "defaults": {
-        "enabled": "true",
-        "selected": "false",
-        "shortcut": "((void*)0)"
-      },
-      "funcname": "MenuItem",
-      "ov_cimguiname": "igMenuItemBool",
-      "ret": "bool",
-      "signature": "(const char*,const char*,bool,bool)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,const char* shortcut,bool* p_selected,bool enabled)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "shortcut",
-          "type": "const char*"
-        },
-        {
-          "name": "p_selected",
-          "type": "bool*"
-        },
-        {
-          "name": "enabled",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const char* label,const char* shortcut,bool* p_selected,bool enabled=true)",
-      "call_args": "(label,shortcut,p_selected,enabled)",
-      "cimguiname": "igMenuItem",
-      "comment": "",
-      "defaults": {
-        "enabled": "true"
-      },
-      "funcname": "MenuItem",
-      "ov_cimguiname": "igMenuItemBoolPtr",
-      "ret": "bool",
-      "signature": "(const char*,const char*,bool*,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igNewFrame": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igNewFrame",
-      "comment": "",
-      "defaults": [],
-      "funcname": "NewFrame",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igNewLine": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igNewLine",
-      "comment": "",
-      "defaults": [],
-      "funcname": "NewLine",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igNextColumn": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igNextColumn",
-      "comment": "",
-      "defaults": [],
-      "funcname": "NextColumn",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igOpenPopup": [
-    {
-      "args": "(const char* str_id)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id)",
-      "call_args": "(str_id)",
-      "cimguiname": "igOpenPopup",
-      "comment": "",
-      "defaults": [],
-      "funcname": "OpenPopup",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igOpenPopupOnItemClick": [
-    {
-      "args": "(const char* str_id,int mouse_button)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "mouse_button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* str_id=((void*)0),int mouse_button=1)",
-      "call_args": "(str_id,mouse_button)",
-      "cimguiname": "igOpenPopupOnItemClick",
-      "comment": "",
-      "defaults": {
-        "mouse_button": "1",
-        "str_id": "((void*)0)"
-      },
-      "funcname": "OpenPopupOnItemClick",
-      "ret": "bool",
-      "signature": "(const char*,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPlotHistogram": [
-    {
-      "args": "(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "values",
-          "type": "const float*"
-        },
-        {
-          "name": "values_count",
-          "type": "int"
-        },
-        {
-          "name": "values_offset",
-          "type": "int"
-        },
-        {
-          "name": "overlay_text",
-          "type": "const char*"
-        },
-        {
-          "name": "scale_min",
-          "type": "float"
-        },
-        {
-          "name": "scale_max",
-          "type": "float"
-        },
-        {
-          "name": "graph_size",
-          "type": "ImVec2"
-        },
-        {
-          "name": "stride",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,const float* values,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282347e+38F,float scale_max=3.40282347e+38F,ImVec2 graph_size=ImVec2(0,0),int stride=sizeof(float))",
-      "call_args": "(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride)",
-      "cimguiname": "igPlotHistogram",
-      "comment": "",
-      "defaults": {
-        "graph_size": "ImVec2(0,0)",
-        "overlay_text": "((void*)0)",
-        "scale_max": "FLT_MAX",
-        "scale_min": "FLT_MAX",
-        "stride": "sizeof(float)",
-        "values_offset": "0"
-      },
-      "funcname": "PlotHistogram",
-      "ov_cimguiname": "igPlotHistogramFloatPtr",
-      "ret": "void",
-      "signature": "(const char*,const float*,int,int,const char*,float,float,ImVec2,int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "values_getter",
-          "ret": "float",
-          "signature": "(void* data,int idx)",
-          "type": "float(*)(void* data,int idx)"
-        },
-        {
-          "name": "data",
-          "type": "void*"
-        },
-        {
-          "name": "values_count",
-          "type": "int"
-        },
-        {
-          "name": "values_offset",
-          "type": "int"
-        },
-        {
-          "name": "overlay_text",
-          "type": "const char*"
-        },
-        {
-          "name": "scale_min",
-          "type": "float"
-        },
-        {
-          "name": "scale_max",
-          "type": "float"
-        },
-        {
-          "name": "graph_size",
-          "type": "ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282347e+38F,float scale_max=3.40282347e+38F,ImVec2 graph_size=ImVec2(0,0))",
-      "call_args": "(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size)",
-      "cimguiname": "igPlotHistogram",
-      "comment": "",
-      "defaults": {
-        "graph_size": "ImVec2(0,0)",
-        "overlay_text": "((void*)0)",
-        "scale_max": "FLT_MAX",
-        "scale_min": "FLT_MAX",
-        "values_offset": "0"
-      },
-      "funcname": "PlotHistogram",
-      "ov_cimguiname": "igPlotHistogramFnPtr",
-      "ret": "void",
-      "signature": "(const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPlotLines": [
-    {
-      "args": "(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "values",
-          "type": "const float*"
-        },
-        {
-          "name": "values_count",
-          "type": "int"
-        },
-        {
-          "name": "values_offset",
-          "type": "int"
-        },
-        {
-          "name": "overlay_text",
-          "type": "const char*"
-        },
-        {
-          "name": "scale_min",
-          "type": "float"
-        },
-        {
-          "name": "scale_max",
-          "type": "float"
-        },
-        {
-          "name": "graph_size",
-          "type": "ImVec2"
-        },
-        {
-          "name": "stride",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,const float* values,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282347e+38F,float scale_max=3.40282347e+38F,ImVec2 graph_size=ImVec2(0,0),int stride=sizeof(float))",
-      "call_args": "(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride)",
-      "cimguiname": "igPlotLines",
-      "comment": "",
-      "defaults": {
-        "graph_size": "ImVec2(0,0)",
-        "overlay_text": "((void*)0)",
-        "scale_max": "FLT_MAX",
-        "scale_min": "FLT_MAX",
-        "stride": "sizeof(float)",
-        "values_offset": "0"
-      },
-      "funcname": "PlotLines",
-      "ov_cimguiname": "igPlotLines",
-      "ret": "void",
-      "signature": "(const char*,const float*,int,int,const char*,float,float,ImVec2,int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "values_getter",
-          "ret": "float",
-          "signature": "(void* data,int idx)",
-          "type": "float(*)(void* data,int idx)"
-        },
-        {
-          "name": "data",
-          "type": "void*"
-        },
-        {
-          "name": "values_count",
-          "type": "int"
-        },
-        {
-          "name": "values_offset",
-          "type": "int"
-        },
-        {
-          "name": "overlay_text",
-          "type": "const char*"
-        },
-        {
-          "name": "scale_min",
-          "type": "float"
-        },
-        {
-          "name": "scale_max",
-          "type": "float"
-        },
-        {
-          "name": "graph_size",
-          "type": "ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282347e+38F,float scale_max=3.40282347e+38F,ImVec2 graph_size=ImVec2(0,0))",
-      "call_args": "(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size)",
-      "cimguiname": "igPlotLines",
-      "comment": "",
-      "defaults": {
-        "graph_size": "ImVec2(0,0)",
-        "overlay_text": "((void*)0)",
-        "scale_max": "FLT_MAX",
-        "scale_min": "FLT_MAX",
-        "values_offset": "0"
-      },
-      "funcname": "PlotLines",
-      "ov_cimguiname": "igPlotLinesFnPtr",
-      "ret": "void",
-      "signature": "(const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopAllowKeyboardFocus": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopAllowKeyboardFocus",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopAllowKeyboardFocus",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopButtonRepeat": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopButtonRepeat",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopButtonRepeat",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopClipRect": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopClipRect",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopClipRect",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopFont": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopFont",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopFont",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopID": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopID",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopItemWidth": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopItemWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopItemWidth",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopStyleColor": [
-    {
-      "args": "(int count)",
-      "argsT": [
-        {
-          "name": "count",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int count=1)",
-      "call_args": "(count)",
-      "cimguiname": "igPopStyleColor",
-      "comment": "",
-      "defaults": {
-        "count": "1"
-      },
-      "funcname": "PopStyleColor",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopStyleVar": [
-    {
-      "args": "(int count)",
-      "argsT": [
-        {
-          "name": "count",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int count=1)",
-      "call_args": "(count)",
-      "cimguiname": "igPopStyleVar",
-      "comment": "",
-      "defaults": {
-        "count": "1"
-      },
-      "funcname": "PopStyleVar",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPopTextWrapPos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igPopTextWrapPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PopTextWrapPos",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igProgressBar": [
-    {
-      "args": "(float fraction,const ImVec2 size_arg,const char* overlay)",
-      "argsT": [
-        {
-          "name": "fraction",
-          "type": "float"
-        },
-        {
-          "name": "size_arg",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "overlay",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(float fraction,const ImVec2& size_arg=ImVec2(-1,0),const char* overlay=((void*)0))",
-      "call_args": "(fraction,size_arg,overlay)",
-      "cimguiname": "igProgressBar",
-      "comment": "",
-      "defaults": {
-        "overlay": "((void*)0)",
-        "size_arg": "ImVec2(-1,0)"
-      },
-      "funcname": "ProgressBar",
-      "ret": "void",
-      "signature": "(float,const ImVec2,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushAllowKeyboardFocus": [
-    {
-      "args": "(bool allow_keyboard_focus)",
-      "argsT": [
-        {
-          "name": "allow_keyboard_focus",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(bool allow_keyboard_focus)",
-      "call_args": "(allow_keyboard_focus)",
-      "cimguiname": "igPushAllowKeyboardFocus",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushAllowKeyboardFocus",
-      "ret": "void",
-      "signature": "(bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushButtonRepeat": [
-    {
-      "args": "(bool repeat)",
-      "argsT": [
-        {
-          "name": "repeat",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(bool repeat)",
-      "call_args": "(repeat)",
-      "cimguiname": "igPushButtonRepeat",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushButtonRepeat",
-      "ret": "void",
-      "signature": "(bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushClipRect": [
-    {
-      "args": "(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)",
-      "argsT": [
-        {
-          "name": "clip_rect_min",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "clip_rect_max",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "intersect_with_current_clip_rect",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& clip_rect_min,const ImVec2& clip_rect_max,bool intersect_with_current_clip_rect)",
-      "call_args": "(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect)",
-      "cimguiname": "igPushClipRect",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushClipRect",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,bool)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushFont": [
-    {
-      "args": "(ImFont* font)",
-      "argsT": [
-        {
-          "name": "font",
-          "type": "ImFont*"
-        }
-      ],
-      "argsoriginal": "(ImFont* font)",
-      "call_args": "(font)",
-      "cimguiname": "igPushFont",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushFont",
-      "ret": "void",
-      "signature": "(ImFont*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushID": [
-    {
-      "args": "(const char* str_id)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id)",
-      "call_args": "(str_id)",
-      "cimguiname": "igPushID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushID",
-      "ov_cimguiname": "igPushIDStr",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* str_id_begin,const char* str_id_end)",
-      "argsT": [
-        {
-          "name": "str_id_begin",
-          "type": "const char*"
-        },
-        {
-          "name": "str_id_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id_begin,const char* str_id_end)",
-      "call_args": "(str_id_begin,str_id_end)",
-      "cimguiname": "igPushID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushID",
-      "ov_cimguiname": "igPushIDRange",
-      "ret": "void",
-      "signature": "(const char*,const char*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id)",
-      "call_args": "(ptr_id)",
-      "cimguiname": "igPushID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushID",
-      "ov_cimguiname": "igPushIDPtr",
-      "ret": "void",
-      "signature": "(const void*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(int int_id)",
-      "argsT": [
-        {
-          "name": "int_id",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int int_id)",
-      "call_args": "(int_id)",
-      "cimguiname": "igPushID",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushID",
-      "ov_cimguiname": "igPushIDInt",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushItemWidth": [
-    {
-      "args": "(float item_width)",
-      "argsT": [
-        {
-          "name": "item_width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float item_width)",
-      "call_args": "(item_width)",
-      "cimguiname": "igPushItemWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushItemWidth",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushStyleColor": [
-    {
-      "args": "(ImGuiCol idx,ImU32 col)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiCol"
-        },
-        {
-          "name": "col",
-          "type": "ImU32"
-        }
-      ],
-      "argsoriginal": "(ImGuiCol idx,ImU32 col)",
-      "call_args": "(idx,col)",
-      "cimguiname": "igPushStyleColor",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushStyleColor",
-      "ov_cimguiname": "igPushStyleColorU32",
-      "ret": "void",
-      "signature": "(ImGuiCol,ImU32)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImGuiCol idx,const ImVec4 col)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiCol"
-        },
-        {
-          "name": "col",
-          "type": "const ImVec4"
-        }
-      ],
-      "argsoriginal": "(ImGuiCol idx,const ImVec4& col)",
-      "call_args": "(idx,col)",
-      "cimguiname": "igPushStyleColor",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushStyleColor",
-      "ov_cimguiname": "igPushStyleColor",
-      "ret": "void",
-      "signature": "(ImGuiCol,const ImVec4)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushStyleVar": [
-    {
-      "args": "(ImGuiStyleVar idx,float val)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiStyleVar"
-        },
-        {
-          "name": "val",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(ImGuiStyleVar idx,float val)",
-      "call_args": "(idx,val)",
-      "cimguiname": "igPushStyleVar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushStyleVar",
-      "ov_cimguiname": "igPushStyleVarFloat",
-      "ret": "void",
-      "signature": "(ImGuiStyleVar,float)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(ImGuiStyleVar idx,const ImVec2 val)",
-      "argsT": [
-        {
-          "name": "idx",
-          "type": "ImGuiStyleVar"
-        },
-        {
-          "name": "val",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(ImGuiStyleVar idx,const ImVec2& val)",
-      "call_args": "(idx,val)",
-      "cimguiname": "igPushStyleVar",
-      "comment": "",
-      "defaults": [],
-      "funcname": "PushStyleVar",
-      "ov_cimguiname": "igPushStyleVarVec2",
-      "ret": "void",
-      "signature": "(ImGuiStyleVar,const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igPushTextWrapPos": [
-    {
-      "args": "(float wrap_local_pos_x)",
-      "argsT": [
-        {
-          "name": "wrap_local_pos_x",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float wrap_local_pos_x=0.0f)",
-      "call_args": "(wrap_local_pos_x)",
-      "cimguiname": "igPushTextWrapPos",
-      "comment": "",
-      "defaults": {
-        "wrap_local_pos_x": "0.0f"
-      },
-      "funcname": "PushTextWrapPos",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igRadioButton": [
-    {
-      "args": "(const char* label,bool active)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "active",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool active)",
-      "call_args": "(label,active)",
-      "cimguiname": "igRadioButton",
-      "comment": "",
-      "defaults": [],
-      "funcname": "RadioButton",
-      "ov_cimguiname": "igRadioButtonBool",
-      "ret": "bool",
-      "signature": "(const char*,bool)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,int* v,int v_button)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int*"
-        },
-        {
-          "name": "v_button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* v,int v_button)",
-      "call_args": "(label,v,v_button)",
-      "cimguiname": "igRadioButton",
-      "comment": "",
-      "defaults": [],
-      "funcname": "RadioButton",
-      "ov_cimguiname": "igRadioButtonIntPtr",
-      "ret": "bool",
-      "signature": "(const char*,int*,int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igRender": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igRender",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Render",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igResetMouseDragDelta": [
-    {
-      "args": "(int button)",
-      "argsT": [
-        {
-          "name": "button",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int button=0)",
-      "call_args": "(button)",
-      "cimguiname": "igResetMouseDragDelta",
-      "comment": "",
-      "defaults": {
-        "button": "0"
-      },
-      "funcname": "ResetMouseDragDelta",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSameLine": [
-    {
-      "args": "(float local_pos_x,float spacing_w)",
-      "argsT": [
-        {
-          "name": "local_pos_x",
-          "type": "float"
-        },
-        {
-          "name": "spacing_w",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float local_pos_x=0.0f,float spacing_w=-1.0f)",
-      "call_args": "(local_pos_x,spacing_w)",
-      "cimguiname": "igSameLine",
-      "comment": "",
-      "defaults": {
-        "local_pos_x": "0.0f",
-        "spacing_w": "-1.0f"
-      },
-      "funcname": "SameLine",
-      "ret": "void",
-      "signature": "(float,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSaveIniSettingsToDisk": [
-    {
-      "args": "(const char* ini_filename)",
-      "argsT": [
-        {
-          "name": "ini_filename",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* ini_filename)",
-      "call_args": "(ini_filename)",
-      "cimguiname": "igSaveIniSettingsToDisk",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SaveIniSettingsToDisk",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSaveIniSettingsToMemory": [
-    {
-      "args": "(size_t* out_ini_size)",
-      "argsT": [
-        {
-          "name": "out_ini_size",
-          "type": "size_t*"
-        }
-      ],
-      "argsoriginal": "(size_t* out_ini_size=((void*)0))",
-      "call_args": "(out_ini_size)",
-      "cimguiname": "igSaveIniSettingsToMemory",
-      "comment": "",
-      "defaults": {
-        "out_ini_size": "((void*)0)"
-      },
-      "funcname": "SaveIniSettingsToMemory",
-      "ret": "const char*",
-      "signature": "(size_t*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSelectable": [
-    {
-      "args": "(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "selected",
-          "type": "bool"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiSelectableFlags"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool selected=false,ImGuiSelectableFlags flags=0,const ImVec2& size=ImVec2(0,0))",
-      "call_args": "(label,selected,flags,size)",
-      "cimguiname": "igSelectable",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "selected": "false",
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "Selectable",
-      "ov_cimguiname": "igSelectable",
-      "ret": "bool",
-      "signature": "(const char*,bool,ImGuiSelectableFlags,const ImVec2)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "p_selected",
-          "type": "bool*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiSelectableFlags"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const char* label,bool* p_selected,ImGuiSelectableFlags flags=0,const ImVec2& size=ImVec2(0,0))",
-      "call_args": "(label,p_selected,flags,size)",
-      "cimguiname": "igSelectable",
-      "comment": "",
-      "defaults": {
-        "flags": "0",
-        "size": "ImVec2(0,0)"
-      },
-      "funcname": "Selectable",
-      "ov_cimguiname": "igSelectableBoolPtr",
-      "ret": "bool",
-      "signature": "(const char*,bool*,ImGuiSelectableFlags,const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSeparator": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igSeparator",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Separator",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetAllocatorFunctions": [
-    {
-      "args": "(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data)",
-      "argsT": [
-        {
-          "name": "alloc_func",
-          "ret": "void*",
-          "signature": "(size_t sz,void* user_data)",
-          "type": "void*(*)(size_t sz,void* user_data)"
-        },
-        {
-          "name": "free_func",
-          "ret": "void",
-          "signature": "(void* ptr,void* user_data)",
-          "type": "void(*)(void* ptr,void* user_data)"
-        },
-        {
-          "name": "user_data",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data=((void*)0))",
-      "call_args": "(alloc_func,free_func,user_data)",
-      "cimguiname": "igSetAllocatorFunctions",
-      "comment": "",
-      "defaults": {
-        "user_data": "((void*)0)"
-      },
-      "funcname": "SetAllocatorFunctions",
-      "ret": "void",
-      "signature": "(void*(*)(size_t,void*),void(*)(void*,void*),void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetClipboardText": [
-    {
-      "args": "(const char* text)",
-      "argsT": [
-        {
-          "name": "text",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* text)",
-      "call_args": "(text)",
-      "cimguiname": "igSetClipboardText",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetClipboardText",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetColorEditOptions": [
-    {
-      "args": "(ImGuiColorEditFlags flags)",
-      "argsT": [
-        {
-          "name": "flags",
-          "type": "ImGuiColorEditFlags"
-        }
-      ],
-      "argsoriginal": "(ImGuiColorEditFlags flags)",
-      "call_args": "(flags)",
-      "cimguiname": "igSetColorEditOptions",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetColorEditOptions",
-      "ret": "void",
-      "signature": "(ImGuiColorEditFlags)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetColumnOffset": [
-    {
-      "args": "(int column_index,float offset_x)",
-      "argsT": [
-        {
-          "name": "column_index",
-          "type": "int"
-        },
-        {
-          "name": "offset_x",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int column_index,float offset_x)",
-      "call_args": "(column_index,offset_x)",
-      "cimguiname": "igSetColumnOffset",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetColumnOffset",
-      "ret": "void",
-      "signature": "(int,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetColumnWidth": [
-    {
-      "args": "(int column_index,float width)",
-      "argsT": [
-        {
-          "name": "column_index",
-          "type": "int"
-        },
-        {
-          "name": "width",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(int column_index,float width)",
-      "call_args": "(column_index,width)",
-      "cimguiname": "igSetColumnWidth",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetColumnWidth",
-      "ret": "void",
-      "signature": "(int,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetCurrentContext": [
-    {
-      "args": "(ImGuiContext* ctx)",
-      "argsT": [
-        {
-          "name": "ctx",
-          "type": "ImGuiContext*"
-        }
-      ],
-      "argsoriginal": "(ImGuiContext* ctx)",
-      "call_args": "(ctx)",
-      "cimguiname": "igSetCurrentContext",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetCurrentContext",
-      "ret": "void",
-      "signature": "(ImGuiContext*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetCursorPos": [
-    {
-      "args": "(const ImVec2 local_pos)",
-      "argsT": [
-        {
-          "name": "local_pos",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& local_pos)",
-      "call_args": "(local_pos)",
-      "cimguiname": "igSetCursorPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetCursorPos",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetCursorPosX": [
-    {
-      "args": "(float local_x)",
-      "argsT": [
-        {
-          "name": "local_x",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float local_x)",
-      "call_args": "(local_x)",
-      "cimguiname": "igSetCursorPosX",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetCursorPosX",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetCursorPosY": [
-    {
-      "args": "(float local_y)",
-      "argsT": [
-        {
-          "name": "local_y",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float local_y)",
-      "call_args": "(local_y)",
-      "cimguiname": "igSetCursorPosY",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetCursorPosY",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetCursorScreenPos": [
-    {
-      "args": "(const ImVec2 pos)",
-      "argsT": [
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos)",
-      "call_args": "(pos)",
-      "cimguiname": "igSetCursorScreenPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetCursorScreenPos",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetDragDropPayload": [
-    {
-      "args": "(const char* type,const void* data,size_t size,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "type",
-          "type": "const char*"
-        },
-        {
-          "name": "data",
-          "type": "const void*"
-        },
-        {
-          "name": "size",
-          "type": "size_t"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const char* type,const void* data,size_t size,ImGuiCond cond=0)",
-      "call_args": "(type,data,size,cond)",
-      "cimguiname": "igSetDragDropPayload",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetDragDropPayload",
-      "ret": "bool",
-      "signature": "(const char*,const void*,size_t,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetItemAllowOverlap": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igSetItemAllowOverlap",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetItemAllowOverlap",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetItemDefaultFocus": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igSetItemDefaultFocus",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetItemDefaultFocus",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetKeyboardFocusHere": [
-    {
-      "args": "(int offset)",
-      "argsT": [
-        {
-          "name": "offset",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(int offset=0)",
-      "call_args": "(offset)",
-      "cimguiname": "igSetKeyboardFocusHere",
-      "comment": "",
-      "defaults": {
-        "offset": "0"
-      },
-      "funcname": "SetKeyboardFocusHere",
-      "ret": "void",
-      "signature": "(int)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetMouseCursor": [
-    {
-      "args": "(ImGuiMouseCursor type)",
-      "argsT": [
-        {
-          "name": "type",
-          "type": "ImGuiMouseCursor"
-        }
-      ],
-      "argsoriginal": "(ImGuiMouseCursor type)",
-      "call_args": "(type)",
-      "cimguiname": "igSetMouseCursor",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetMouseCursor",
-      "ret": "void",
-      "signature": "(ImGuiMouseCursor)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextTreeNodeOpen": [
-    {
-      "args": "(bool is_open,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "is_open",
-          "type": "bool"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(bool is_open,ImGuiCond cond=0)",
-      "call_args": "(is_open,cond)",
-      "cimguiname": "igSetNextTreeNodeOpen",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetNextTreeNodeOpen",
-      "ret": "void",
-      "signature": "(bool,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowBgAlpha": [
-    {
-      "args": "(float alpha)",
-      "argsT": [
-        {
-          "name": "alpha",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float alpha)",
-      "call_args": "(alpha)",
-      "cimguiname": "igSetNextWindowBgAlpha",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetNextWindowBgAlpha",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowCollapsed": [
-    {
-      "args": "(bool collapsed,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "collapsed",
-          "type": "bool"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(bool collapsed,ImGuiCond cond=0)",
-      "call_args": "(collapsed,cond)",
-      "cimguiname": "igSetNextWindowCollapsed",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetNextWindowCollapsed",
-      "ret": "void",
-      "signature": "(bool,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowContentSize": [
-    {
-      "args": "(const ImVec2 size)",
-      "argsT": [
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& size)",
-      "call_args": "(size)",
-      "cimguiname": "igSetNextWindowContentSize",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetNextWindowContentSize",
-      "ret": "void",
-      "signature": "(const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowFocus": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igSetNextWindowFocus",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetNextWindowFocus",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowPos": [
-    {
-      "args": "(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)",
-      "argsT": [
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        },
-        {
-          "name": "pivot",
-          "type": "const ImVec2"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos,ImGuiCond cond=0,const ImVec2& pivot=ImVec2(0,0))",
-      "call_args": "(pos,cond,pivot)",
-      "cimguiname": "igSetNextWindowPos",
-      "comment": "",
-      "defaults": {
-        "cond": "0",
-        "pivot": "ImVec2(0,0)"
-      },
-      "funcname": "SetNextWindowPos",
-      "ret": "void",
-      "signature": "(const ImVec2,ImGuiCond,const ImVec2)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowSize": [
-    {
-      "args": "(const ImVec2 size,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& size,ImGuiCond cond=0)",
-      "call_args": "(size,cond)",
-      "cimguiname": "igSetNextWindowSize",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetNextWindowSize",
-      "ret": "void",
-      "signature": "(const ImVec2,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetNextWindowSizeConstraints": [
-    {
-      "args": "(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data)",
-      "argsT": [
-        {
-          "name": "size_min",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "size_max",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "custom_callback",
-          "type": "ImGuiSizeCallback"
-        },
-        {
-          "name": "custom_callback_data",
-          "type": "void*"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& size_min,const ImVec2& size_max,ImGuiSizeCallback custom_callback=((void*)0),void* custom_callback_data=((void*)0))",
-      "call_args": "(size_min,size_max,custom_callback,custom_callback_data)",
-      "cimguiname": "igSetNextWindowSizeConstraints",
-      "comment": "",
-      "defaults": {
-        "custom_callback": "((void*)0)",
-        "custom_callback_data": "((void*)0)"
-      },
-      "funcname": "SetNextWindowSizeConstraints",
-      "ret": "void",
-      "signature": "(const ImVec2,const ImVec2,ImGuiSizeCallback,void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetScrollFromPosY": [
-    {
-      "args": "(float local_y,float center_y_ratio)",
-      "argsT": [
-        {
-          "name": "local_y",
-          "type": "float"
-        },
-        {
-          "name": "center_y_ratio",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float local_y,float center_y_ratio=0.5f)",
-      "call_args": "(local_y,center_y_ratio)",
-      "cimguiname": "igSetScrollFromPosY",
-      "comment": "",
-      "defaults": {
-        "center_y_ratio": "0.5f"
-      },
-      "funcname": "SetScrollFromPosY",
-      "ret": "void",
-      "signature": "(float,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetScrollHereY": [
-    {
-      "args": "(float center_y_ratio)",
-      "argsT": [
-        {
-          "name": "center_y_ratio",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float center_y_ratio=0.5f)",
-      "call_args": "(center_y_ratio)",
-      "cimguiname": "igSetScrollHereY",
-      "comment": "",
-      "defaults": {
-        "center_y_ratio": "0.5f"
-      },
-      "funcname": "SetScrollHereY",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetScrollX": [
-    {
-      "args": "(float scroll_x)",
-      "argsT": [
-        {
-          "name": "scroll_x",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float scroll_x)",
-      "call_args": "(scroll_x)",
-      "cimguiname": "igSetScrollX",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetScrollX",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetScrollY": [
-    {
-      "args": "(float scroll_y)",
-      "argsT": [
-        {
-          "name": "scroll_y",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float scroll_y)",
-      "call_args": "(scroll_y)",
-      "cimguiname": "igSetScrollY",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetScrollY",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetStateStorage": [
-    {
-      "args": "(ImGuiStorage* storage)",
-      "argsT": [
-        {
-          "name": "storage",
-          "type": "ImGuiStorage*"
-        }
-      ],
-      "argsoriginal": "(ImGuiStorage* storage)",
-      "call_args": "(storage)",
-      "cimguiname": "igSetStateStorage",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetStateStorage",
-      "ret": "void",
-      "signature": "(ImGuiStorage*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetTabItemClosed": [
-    {
-      "args": "(const char* tab_or_docked_window_label)",
-      "argsT": [
-        {
-          "name": "tab_or_docked_window_label",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* tab_or_docked_window_label)",
-      "call_args": "(tab_or_docked_window_label)",
-      "cimguiname": "igSetTabItemClosed",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetTabItemClosed",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetTooltip": [
-    {
-      "args": "(const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "igSetTooltip",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetTooltip",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetTooltipV": [
-    {
-      "args": "(const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* fmt,va_list args)",
-      "call_args": "(fmt,args)",
-      "cimguiname": "igSetTooltipV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetTooltipV",
-      "ret": "void",
-      "signature": "(const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetWindowCollapsed": [
-    {
-      "args": "(bool collapsed,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "collapsed",
-          "type": "bool"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(bool collapsed,ImGuiCond cond=0)",
-      "call_args": "(collapsed,cond)",
-      "cimguiname": "igSetWindowCollapsed",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetWindowCollapsed",
-      "ov_cimguiname": "igSetWindowCollapsedBool",
-      "ret": "void",
-      "signature": "(bool,ImGuiCond)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* name,bool collapsed,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "name",
-          "type": "const char*"
-        },
-        {
-          "name": "collapsed",
-          "type": "bool"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const char* name,bool collapsed,ImGuiCond cond=0)",
-      "call_args": "(name,collapsed,cond)",
-      "cimguiname": "igSetWindowCollapsed",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetWindowCollapsed",
-      "ov_cimguiname": "igSetWindowCollapsedStr",
-      "ret": "void",
-      "signature": "(const char*,bool,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetWindowFocus": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igSetWindowFocus",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetWindowFocus",
-      "ov_cimguiname": "igSetWindowFocus",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* name)",
-      "argsT": [
-        {
-          "name": "name",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* name)",
-      "call_args": "(name)",
-      "cimguiname": "igSetWindowFocus",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetWindowFocus",
-      "ov_cimguiname": "igSetWindowFocusStr",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetWindowFontScale": [
-    {
-      "args": "(float scale)",
-      "argsT": [
-        {
-          "name": "scale",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float scale)",
-      "call_args": "(scale)",
-      "cimguiname": "igSetWindowFontScale",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SetWindowFontScale",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetWindowPos": [
-    {
-      "args": "(const ImVec2 pos,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& pos,ImGuiCond cond=0)",
-      "call_args": "(pos,cond)",
-      "cimguiname": "igSetWindowPos",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetWindowPos",
-      "ov_cimguiname": "igSetWindowPosVec2",
-      "ret": "void",
-      "signature": "(const ImVec2,ImGuiCond)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* name,const ImVec2 pos,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "name",
-          "type": "const char*"
-        },
-        {
-          "name": "pos",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const char* name,const ImVec2& pos,ImGuiCond cond=0)",
-      "call_args": "(name,pos,cond)",
-      "cimguiname": "igSetWindowPos",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetWindowPos",
-      "ov_cimguiname": "igSetWindowPosStr",
-      "ret": "void",
-      "signature": "(const char*,const ImVec2,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSetWindowSize": [
-    {
-      "args": "(const ImVec2 size,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const ImVec2& size,ImGuiCond cond=0)",
-      "call_args": "(size,cond)",
-      "cimguiname": "igSetWindowSize",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetWindowSize",
-      "ov_cimguiname": "igSetWindowSizeVec2",
-      "ret": "void",
-      "signature": "(const ImVec2,ImGuiCond)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* name,const ImVec2 size,ImGuiCond cond)",
-      "argsT": [
-        {
-          "name": "name",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "cond",
-          "type": "ImGuiCond"
-        }
-      ],
-      "argsoriginal": "(const char* name,const ImVec2& size,ImGuiCond cond=0)",
-      "call_args": "(name,size,cond)",
-      "cimguiname": "igSetWindowSize",
-      "comment": "",
-      "defaults": {
-        "cond": "0"
-      },
-      "funcname": "SetWindowSize",
-      "ov_cimguiname": "igSetWindowSizeStr",
-      "ret": "void",
-      "signature": "(const char*,const ImVec2,ImGuiCond)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowAboutWindow": [
-    {
-      "args": "(bool* p_open)",
-      "argsT": [
-        {
-          "name": "p_open",
-          "type": "bool*"
-        }
-      ],
-      "argsoriginal": "(bool* p_open=((void*)0))",
-      "call_args": "(p_open)",
-      "cimguiname": "igShowAboutWindow",
-      "comment": "",
-      "defaults": {
-        "p_open": "((void*)0)"
-      },
-      "funcname": "ShowAboutWindow",
-      "ret": "void",
-      "signature": "(bool*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowDemoWindow": [
-    {
-      "args": "(bool* p_open)",
-      "argsT": [
-        {
-          "name": "p_open",
-          "type": "bool*"
-        }
-      ],
-      "argsoriginal": "(bool* p_open=((void*)0))",
-      "call_args": "(p_open)",
-      "cimguiname": "igShowDemoWindow",
-      "comment": "",
-      "defaults": {
-        "p_open": "((void*)0)"
-      },
-      "funcname": "ShowDemoWindow",
-      "ret": "void",
-      "signature": "(bool*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowFontSelector": [
-    {
-      "args": "(const char* label)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label)",
-      "call_args": "(label)",
-      "cimguiname": "igShowFontSelector",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ShowFontSelector",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowMetricsWindow": [
-    {
-      "args": "(bool* p_open)",
-      "argsT": [
-        {
-          "name": "p_open",
-          "type": "bool*"
-        }
-      ],
-      "argsoriginal": "(bool* p_open=((void*)0))",
-      "call_args": "(p_open)",
-      "cimguiname": "igShowMetricsWindow",
-      "comment": "",
-      "defaults": {
-        "p_open": "((void*)0)"
-      },
-      "funcname": "ShowMetricsWindow",
-      "ret": "void",
-      "signature": "(bool*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowStyleEditor": [
-    {
-      "args": "(ImGuiStyle* ref)",
-      "argsT": [
-        {
-          "name": "ref",
-          "type": "ImGuiStyle*"
-        }
-      ],
-      "argsoriginal": "(ImGuiStyle* ref=((void*)0))",
-      "call_args": "(ref)",
-      "cimguiname": "igShowStyleEditor",
-      "comment": "",
-      "defaults": {
-        "ref": "((void*)0)"
-      },
-      "funcname": "ShowStyleEditor",
-      "ret": "void",
-      "signature": "(ImGuiStyle*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowStyleSelector": [
-    {
-      "args": "(const char* label)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label)",
-      "call_args": "(label)",
-      "cimguiname": "igShowStyleSelector",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ShowStyleSelector",
-      "ret": "bool",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igShowUserGuide": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igShowUserGuide",
-      "comment": "",
-      "defaults": [],
-      "funcname": "ShowUserGuide",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderAngle": [
-    {
-      "args": "(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v_rad",
-          "type": "float*"
-        },
-        {
-          "name": "v_degrees_min",
-          "type": "float"
-        },
-        {
-          "name": "v_degrees_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,float* v_rad,float v_degrees_min=-360.0f,float v_degrees_max=+360.0f,const char* format=\"%.0f deg\")",
-      "call_args": "(label,v_rad,v_degrees_min,v_degrees_max,format)",
-      "cimguiname": "igSliderAngle",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.0f deg\"",
-        "v_degrees_max": "+360.0f",
-        "v_degrees_min": "-360.0f"
-      },
-      "funcname": "SliderAngle",
-      "ret": "bool",
-      "signature": "(const char*,float*,float,float,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderFloat": [
-    {
-      "args": "(const char* label,float* v,float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float*"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float* v,float v_min,float v_max,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_min,v_max,format,power)",
-      "cimguiname": "igSliderFloat",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f"
-      },
-      "funcname": "SliderFloat",
-      "ret": "bool",
-      "signature": "(const char*,float*,float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderFloat2": [
-    {
-      "args": "(const char* label,float v[2],float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[2]"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[2],float v_min,float v_max,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_min,v_max,format,power)",
-      "cimguiname": "igSliderFloat2",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f"
-      },
-      "funcname": "SliderFloat2",
-      "ret": "bool",
-      "signature": "(const char*,float[2],float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderFloat3": [
-    {
-      "args": "(const char* label,float v[3],float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[3]"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[3],float v_min,float v_max,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_min,v_max,format,power)",
-      "cimguiname": "igSliderFloat3",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f"
-      },
-      "funcname": "SliderFloat3",
-      "ret": "bool",
-      "signature": "(const char*,float[3],float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderFloat4": [
-    {
-      "args": "(const char* label,float v[4],float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float[4]"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,float v[4],float v_min,float v_max,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,v,v_min,v_max,format,power)",
-      "cimguiname": "igSliderFloat4",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f"
-      },
-      "funcname": "SliderFloat4",
-      "ret": "bool",
-      "signature": "(const char*,float[4],float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderInt": [
-    {
-      "args": "(const char* label,int* v,int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int*"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int* v,int v_min,int v_max,const char* format=\"%d\")",
-      "call_args": "(label,v,v_min,v_max,format)",
-      "cimguiname": "igSliderInt",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\""
-      },
-      "funcname": "SliderInt",
-      "ret": "bool",
-      "signature": "(const char*,int*,int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderInt2": [
-    {
-      "args": "(const char* label,int v[2],int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[2]"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[2],int v_min,int v_max,const char* format=\"%d\")",
-      "call_args": "(label,v,v_min,v_max,format)",
-      "cimguiname": "igSliderInt2",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\""
-      },
-      "funcname": "SliderInt2",
-      "ret": "bool",
-      "signature": "(const char*,int[2],int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderInt3": [
-    {
-      "args": "(const char* label,int v[3],int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[3]"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[3],int v_min,int v_max,const char* format=\"%d\")",
-      "call_args": "(label,v,v_min,v_max,format)",
-      "cimguiname": "igSliderInt3",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\""
-      },
-      "funcname": "SliderInt3",
-      "ret": "bool",
-      "signature": "(const char*,int[3],int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderInt4": [
-    {
-      "args": "(const char* label,int v[4],int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int[4]"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,int v[4],int v_min,int v_max,const char* format=\"%d\")",
-      "call_args": "(label,v,v_min,v_max,format)",
-      "cimguiname": "igSliderInt4",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\""
-      },
-      "funcname": "SliderInt4",
-      "ret": "bool",
-      "signature": "(const char*,int[4],int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderScalar": [
-    {
-      "args": "(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "v_min",
-          "type": "const void*"
-        },
-        {
-          "name": "v_max",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format=((void*)0),float power=1.0f)",
-      "call_args": "(label,data_type,v,v_min,v_max,format,power)",
-      "cimguiname": "igSliderScalar",
-      "comment": "",
-      "defaults": {
-        "format": "((void*)0)",
-        "power": "1.0f"
-      },
-      "funcname": "SliderScalar",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDataType,void*,const void*,const void*,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSliderScalarN": [
-    {
-      "args": "(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "components",
-          "type": "int"
-        },
-        {
-          "name": "v_min",
-          "type": "const void*"
-        },
-        {
-          "name": "v_max",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_max,const char* format=((void*)0),float power=1.0f)",
-      "call_args": "(label,data_type,v,components,v_min,v_max,format,power)",
-      "cimguiname": "igSliderScalarN",
-      "comment": "",
-      "defaults": {
-        "format": "((void*)0)",
-        "power": "1.0f"
-      },
-      "funcname": "SliderScalarN",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiDataType,void*,int,const void*,const void*,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSmallButton": [
-    {
-      "args": "(const char* label)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label)",
-      "call_args": "(label)",
-      "cimguiname": "igSmallButton",
-      "comment": "",
-      "defaults": [],
-      "funcname": "SmallButton",
-      "ret": "bool",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igSpacing": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igSpacing",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Spacing",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igStyleColorsClassic": [
-    {
-      "args": "(ImGuiStyle* dst)",
-      "argsT": [
-        {
-          "name": "dst",
-          "type": "ImGuiStyle*"
-        }
-      ],
-      "argsoriginal": "(ImGuiStyle* dst=((void*)0))",
-      "call_args": "(dst)",
-      "cimguiname": "igStyleColorsClassic",
-      "comment": "",
-      "defaults": {
-        "dst": "((void*)0)"
-      },
-      "funcname": "StyleColorsClassic",
-      "ret": "void",
-      "signature": "(ImGuiStyle*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igStyleColorsDark": [
-    {
-      "args": "(ImGuiStyle* dst)",
-      "argsT": [
-        {
-          "name": "dst",
-          "type": "ImGuiStyle*"
-        }
-      ],
-      "argsoriginal": "(ImGuiStyle* dst=((void*)0))",
-      "call_args": "(dst)",
-      "cimguiname": "igStyleColorsDark",
-      "comment": "",
-      "defaults": {
-        "dst": "((void*)0)"
-      },
-      "funcname": "StyleColorsDark",
-      "ret": "void",
-      "signature": "(ImGuiStyle*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igStyleColorsLight": [
-    {
-      "args": "(ImGuiStyle* dst)",
-      "argsT": [
-        {
-          "name": "dst",
-          "type": "ImGuiStyle*"
-        }
-      ],
-      "argsoriginal": "(ImGuiStyle* dst=((void*)0))",
-      "call_args": "(dst)",
-      "cimguiname": "igStyleColorsLight",
-      "comment": "",
-      "defaults": {
-        "dst": "((void*)0)"
-      },
-      "funcname": "StyleColorsLight",
-      "ret": "void",
-      "signature": "(ImGuiStyle*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igText": [
-    {
-      "args": "(const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "igText",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Text",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextColored": [
-    {
-      "args": "(const ImVec4 col,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "col",
-          "type": "const ImVec4"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const ImVec4& col,const char* fmt,...)",
-      "call_args": "(col,fmt,...)",
-      "cimguiname": "igTextColored",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextColored",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const ImVec4,const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextColoredV": [
-    {
-      "args": "(const ImVec4 col,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "col",
-          "type": "const ImVec4"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const ImVec4& col,const char* fmt,va_list args)",
-      "call_args": "(col,fmt,args)",
-      "cimguiname": "igTextColoredV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextColoredV",
-      "ret": "void",
-      "signature": "(const ImVec4,const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextDisabled": [
-    {
-      "args": "(const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "igTextDisabled",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextDisabled",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextDisabledV": [
-    {
-      "args": "(const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* fmt,va_list args)",
-      "call_args": "(fmt,args)",
-      "cimguiname": "igTextDisabledV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextDisabledV",
-      "ret": "void",
-      "signature": "(const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextUnformatted": [
-    {
-      "args": "(const char* text,const char* text_end)",
-      "argsT": [
-        {
-          "name": "text",
-          "type": "const char*"
-        },
-        {
-          "name": "text_end",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
-      "call_args": "(text,text_end)",
-      "cimguiname": "igTextUnformatted",
-      "comment": "",
-      "defaults": {
-        "text_end": "((void*)0)"
-      },
-      "funcname": "TextUnformatted",
-      "ret": "void",
-      "signature": "(const char*,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextV": [
-    {
-      "args": "(const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* fmt,va_list args)",
-      "call_args": "(fmt,args)",
-      "cimguiname": "igTextV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextV",
-      "ret": "void",
-      "signature": "(const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextWrapped": [
-    {
-      "args": "(const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* fmt,...)",
-      "call_args": "(fmt,...)",
-      "cimguiname": "igTextWrapped",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextWrapped",
-      "isvararg": "...)",
-      "ret": "void",
-      "signature": "(const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTextWrappedV": [
-    {
-      "args": "(const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* fmt,va_list args)",
-      "call_args": "(fmt,args)",
-      "cimguiname": "igTextWrappedV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TextWrappedV",
-      "ret": "void",
-      "signature": "(const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreeAdvanceToLabelPos": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igTreeAdvanceToLabelPos",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeAdvanceToLabelPos",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreeNode": [
-    {
-      "args": "(const char* label)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label)",
-      "call_args": "(label)",
-      "cimguiname": "igTreeNode",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNode",
-      "ov_cimguiname": "igTreeNodeStr",
-      "ret": "bool",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* str_id,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* str_id,const char* fmt,...)",
-      "call_args": "(str_id,fmt,...)",
-      "cimguiname": "igTreeNode",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNode",
-      "isvararg": "...)",
-      "ov_cimguiname": "igTreeNodeStrStr",
-      "ret": "bool",
-      "signature": "(const char*,const char*,...)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id,const char* fmt,...)",
-      "call_args": "(ptr_id,fmt,...)",
-      "cimguiname": "igTreeNode",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNode",
-      "isvararg": "...)",
-      "ov_cimguiname": "igTreeNodePtr",
-      "ret": "bool",
-      "signature": "(const void*,const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreeNodeEx": [
-    {
-      "args": "(const char* label,ImGuiTreeNodeFlags flags)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        }
-      ],
-      "argsoriginal": "(const char* label,ImGuiTreeNodeFlags flags=0)",
-      "call_args": "(label,flags)",
-      "cimguiname": "igTreeNodeEx",
-      "comment": "",
-      "defaults": {
-        "flags": "0"
-      },
-      "funcname": "TreeNodeEx",
-      "ov_cimguiname": "igTreeNodeExStr",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiTreeNodeFlags)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
-      "call_args": "(str_id,flags,fmt,...)",
-      "cimguiname": "igTreeNodeEx",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNodeEx",
-      "isvararg": "...)",
-      "ov_cimguiname": "igTreeNodeExStrStr",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiTreeNodeFlags,const char*,...)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "...",
-          "type": "..."
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
-      "call_args": "(ptr_id,flags,fmt,...)",
-      "cimguiname": "igTreeNodeEx",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNodeEx",
-      "isvararg": "...)",
-      "ov_cimguiname": "igTreeNodeExPtr",
-      "ret": "bool",
-      "signature": "(const void*,ImGuiTreeNodeFlags,const char*,...)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreeNodeExV": [
-    {
-      "args": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
-      "call_args": "(str_id,flags,fmt,args)",
-      "cimguiname": "igTreeNodeExV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNodeExV",
-      "ov_cimguiname": "igTreeNodeExVStr",
-      "ret": "bool",
-      "signature": "(const char*,ImGuiTreeNodeFlags,const char*,va_list)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        },
-        {
-          "name": "flags",
-          "type": "ImGuiTreeNodeFlags"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
-      "call_args": "(ptr_id,flags,fmt,args)",
-      "cimguiname": "igTreeNodeExV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNodeExV",
-      "ov_cimguiname": "igTreeNodeExVPtr",
-      "ret": "bool",
-      "signature": "(const void*,ImGuiTreeNodeFlags,const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreeNodeV": [
-    {
-      "args": "(const char* str_id,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const char* str_id,const char* fmt,va_list args)",
-      "call_args": "(str_id,fmt,args)",
-      "cimguiname": "igTreeNodeV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNodeV",
-      "ov_cimguiname": "igTreeNodeVStr",
-      "ret": "bool",
-      "signature": "(const char*,const char*,va_list)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id,const char* fmt,va_list args)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        },
-        {
-          "name": "fmt",
-          "type": "const char*"
-        },
-        {
-          "name": "args",
-          "type": "va_list"
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id,const char* fmt,va_list args)",
-      "call_args": "(ptr_id,fmt,args)",
-      "cimguiname": "igTreeNodeV",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreeNodeV",
-      "ov_cimguiname": "igTreeNodeVPtr",
-      "ret": "bool",
-      "signature": "(const void*,const char*,va_list)",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreePop": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "igTreePop",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreePop",
-      "ret": "void",
-      "signature": "()",
-      "stname": "ImGui"
-    }
-  ],
-  "igTreePush": [
-    {
-      "args": "(const char* str_id)",
-      "argsT": [
-        {
-          "name": "str_id",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* str_id)",
-      "call_args": "(str_id)",
-      "cimguiname": "igTreePush",
-      "comment": "",
-      "defaults": [],
-      "funcname": "TreePush",
-      "ov_cimguiname": "igTreePushStr",
-      "ret": "void",
-      "signature": "(const char*)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const void* ptr_id)",
-      "argsT": [
-        {
-          "name": "ptr_id",
-          "type": "const void*"
-        }
-      ],
-      "argsoriginal": "(const void* ptr_id=((void*)0))",
-      "call_args": "(ptr_id)",
-      "cimguiname": "igTreePush",
-      "comment": "",
-      "defaults": {
-        "ptr_id": "((void*)0)"
-      },
-      "funcname": "TreePush",
-      "ov_cimguiname": "igTreePushPtr",
-      "ret": "void",
-      "signature": "(const void*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igUnindent": [
-    {
-      "args": "(float indent_w)",
-      "argsT": [
-        {
-          "name": "indent_w",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(float indent_w=0.0f)",
-      "call_args": "(indent_w)",
-      "cimguiname": "igUnindent",
-      "comment": "",
-      "defaults": {
-        "indent_w": "0.0f"
-      },
-      "funcname": "Unindent",
-      "ret": "void",
-      "signature": "(float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igVSliderFloat": [
-    {
-      "args": "(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "v",
-          "type": "float*"
-        },
-        {
-          "name": "v_min",
-          "type": "float"
-        },
-        {
-          "name": "v_max",
-          "type": "float"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,const ImVec2& size,float* v,float v_min,float v_max,const char* format=\"%.3f\",float power=1.0f)",
-      "call_args": "(label,size,v,v_min,v_max,format,power)",
-      "cimguiname": "igVSliderFloat",
-      "comment": "",
-      "defaults": {
-        "format": "\"%.3f\"",
-        "power": "1.0f"
-      },
-      "funcname": "VSliderFloat",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2,float*,float,float,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igVSliderInt": [
-    {
-      "args": "(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "v",
-          "type": "int*"
-        },
-        {
-          "name": "v_min",
-          "type": "int"
-        },
-        {
-          "name": "v_max",
-          "type": "int"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* label,const ImVec2& size,int* v,int v_min,int v_max,const char* format=\"%d\")",
-      "call_args": "(label,size,v,v_min,v_max,format)",
-      "cimguiname": "igVSliderInt",
-      "comment": "",
-      "defaults": {
-        "format": "\"%d\""
-      },
-      "funcname": "VSliderInt",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2,int*,int,int,const char*)",
-      "stname": "ImGui"
-    }
-  ],
-  "igVSliderScalar": [
-    {
-      "args": "(const char* label,const ImVec2 size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power)",
-      "argsT": [
-        {
-          "name": "label",
-          "type": "const char*"
-        },
-        {
-          "name": "size",
-          "type": "const ImVec2"
-        },
-        {
-          "name": "data_type",
-          "type": "ImGuiDataType"
-        },
-        {
-          "name": "v",
-          "type": "void*"
-        },
-        {
-          "name": "v_min",
-          "type": "const void*"
-        },
-        {
-          "name": "v_max",
-          "type": "const void*"
-        },
-        {
-          "name": "format",
-          "type": "const char*"
-        },
-        {
-          "name": "power",
-          "type": "float"
-        }
-      ],
-      "argsoriginal": "(const char* label,const ImVec2& size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format=((void*)0),float power=1.0f)",
-      "call_args": "(label,size,data_type,v,v_min,v_max,format,power)",
-      "cimguiname": "igVSliderScalar",
-      "comment": "",
-      "defaults": {
-        "format": "((void*)0)",
-        "power": "1.0f"
-      },
-      "funcname": "VSliderScalar",
-      "ret": "bool",
-      "signature": "(const char*,const ImVec2,ImGuiDataType,void*,const void*,const void*,const char*,float)",
-      "stname": "ImGui"
-    }
-  ],
-  "igValue": [
-    {
-      "args": "(const char* prefix,bool b)",
-      "argsT": [
-        {
-          "name": "prefix",
-          "type": "const char*"
-        },
-        {
-          "name": "b",
-          "type": "bool"
-        }
-      ],
-      "argsoriginal": "(const char* prefix,bool b)",
-      "call_args": "(prefix,b)",
-      "cimguiname": "igValue",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Value",
-      "ov_cimguiname": "igValueBool",
-      "ret": "void",
-      "signature": "(const char*,bool)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* prefix,int v)",
-      "argsT": [
-        {
-          "name": "prefix",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "int"
-        }
-      ],
-      "argsoriginal": "(const char* prefix,int v)",
-      "call_args": "(prefix,v)",
-      "cimguiname": "igValue",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Value",
-      "ov_cimguiname": "igValueInt",
-      "ret": "void",
-      "signature": "(const char*,int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* prefix,unsigned int v)",
-      "argsT": [
-        {
-          "name": "prefix",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "unsigned int"
-        }
-      ],
-      "argsoriginal": "(const char* prefix,unsigned int v)",
-      "call_args": "(prefix,v)",
-      "cimguiname": "igValue",
-      "comment": "",
-      "defaults": [],
-      "funcname": "Value",
-      "ov_cimguiname": "igValueUint",
-      "ret": "void",
-      "signature": "(const char*,unsigned int)",
-      "stname": "ImGui"
-    },
-    {
-      "args": "(const char* prefix,float v,const char* float_format)",
-      "argsT": [
-        {
-          "name": "prefix",
-          "type": "const char*"
-        },
-        {
-          "name": "v",
-          "type": "float"
-        },
-        {
-          "name": "float_format",
-          "type": "const char*"
-        }
-      ],
-      "argsoriginal": "(const char* prefix,float v,const char* float_format=((void*)0))",
-      "call_args": "(prefix,v,float_format)",
-      "cimguiname": "igValue",
-      "comment": "",
-      "defaults": {
-        "float_format": "((void*)0)"
-      },
-      "funcname": "Value",
-      "ov_cimguiname": "igValueFloat",
-      "ret": "void",
-      "signature": "(const char*,float,const char*)",
-      "stname": "ImGui"
-    }
-  ]
-}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimgui/definitions.json b/src/CodeGenerator/definitions/cimgui/definitions.json
new file mode 100644
index 00000000..9f26515e
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimgui/definitions.json
@@ -0,0 +1,39570 @@
+{
+  "ImBitArray_ClearAllBits": [
+    {
+      "args": "(ImBitArray* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImBitArray_ClearAllBits",
+      "defaults": {},
+      "funcname": "ClearAllBits",
+      "location": "imgui_internal:603",
+      "ov_cimguiname": "ImBitArray_ClearAllBits",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_ClearBit": [
+    {
+      "args": "(ImBitArray* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImBitArray_ClearBit",
+      "defaults": {},
+      "funcname": "ClearBit",
+      "location": "imgui_internal:607",
+      "ov_cimguiname": "ImBitArray_ClearBit",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_ImBitArray": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImBitArray_ImBitArray",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImBitArray",
+      "location": "imgui_internal:602",
+      "ov_cimguiname": "ImBitArray_ImBitArray",
+      "signature": "()",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_SetAllBits": [
+    {
+      "args": "(ImBitArray* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImBitArray_SetAllBits",
+      "defaults": {},
+      "funcname": "SetAllBits",
+      "location": "imgui_internal:604",
+      "ov_cimguiname": "ImBitArray_SetAllBits",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_SetBit": [
+    {
+      "args": "(ImBitArray* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImBitArray_SetBit",
+      "defaults": {},
+      "funcname": "SetBit",
+      "location": "imgui_internal:606",
+      "ov_cimguiname": "ImBitArray_SetBit",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_SetBitRange": [
+    {
+      "args": "(ImBitArray* self,int n,int n2)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "n2",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n,int n2)",
+      "call_args": "(n,n2)",
+      "cimguiname": "ImBitArray_SetBitRange",
+      "defaults": {},
+      "funcname": "SetBitRange",
+      "location": "imgui_internal:608",
+      "ov_cimguiname": "ImBitArray_SetBitRange",
+      "ret": "void",
+      "signature": "(int,int)",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_TestBit": [
+    {
+      "args": "(ImBitArray* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImBitArray_TestBit",
+      "defaults": {},
+      "funcname": "TestBit",
+      "location": "imgui_internal:605",
+      "ov_cimguiname": "ImBitArray_TestBit",
+      "ret": "bool",
+      "signature": "(int)const",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitArray_destroy": [
+    {
+      "args": "(ImBitArray* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitArray*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImBitArray_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:602",
+      "ov_cimguiname": "ImBitArray_destroy",
+      "ret": "void",
+      "signature": "(ImBitArray*)",
+      "stname": "ImBitArray",
+      "templated": true
+    }
+  ],
+  "ImBitVector_Clear": [
+    {
+      "args": "(ImBitVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImBitVector_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui_internal:618",
+      "ov_cimguiname": "ImBitVector_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImBitVector"
+    }
+  ],
+  "ImBitVector_ClearBit": [
+    {
+      "args": "(ImBitVector* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitVector*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImBitVector_ClearBit",
+      "defaults": {},
+      "funcname": "ClearBit",
+      "location": "imgui_internal:621",
+      "ov_cimguiname": "ImBitVector_ClearBit",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImBitVector"
+    }
+  ],
+  "ImBitVector_Create": [
+    {
+      "args": "(ImBitVector* self,int sz)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitVector*"
+        },
+        {
+          "name": "sz",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int sz)",
+      "call_args": "(sz)",
+      "cimguiname": "ImBitVector_Create",
+      "defaults": {},
+      "funcname": "Create",
+      "location": "imgui_internal:617",
+      "ov_cimguiname": "ImBitVector_Create",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImBitVector"
+    }
+  ],
+  "ImBitVector_SetBit": [
+    {
+      "args": "(ImBitVector* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitVector*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImBitVector_SetBit",
+      "defaults": {},
+      "funcname": "SetBit",
+      "location": "imgui_internal:620",
+      "ov_cimguiname": "ImBitVector_SetBit",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImBitVector"
+    }
+  ],
+  "ImBitVector_TestBit": [
+    {
+      "args": "(ImBitVector* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImBitVector*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImBitVector_TestBit",
+      "defaults": {},
+      "funcname": "TestBit",
+      "location": "imgui_internal:619",
+      "ov_cimguiname": "ImBitVector_TestBit",
+      "ret": "bool",
+      "signature": "(int)const",
+      "stname": "ImBitVector"
+    }
+  ],
+  "ImChunkStream_alloc_chunk": [
+    {
+      "args": "(ImChunkStream* self,size_t sz)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        },
+        {
+          "name": "sz",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(size_t sz)",
+      "call_args": "(sz)",
+      "cimguiname": "ImChunkStream_alloc_chunk",
+      "defaults": {},
+      "funcname": "alloc_chunk",
+      "location": "imgui_internal:722",
+      "ov_cimguiname": "ImChunkStream_alloc_chunk",
+      "ret": "T*",
+      "signature": "(size_t)",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_begin": [
+    {
+      "args": "(ImChunkStream* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImChunkStream_begin",
+      "defaults": {},
+      "funcname": "begin",
+      "location": "imgui_internal:723",
+      "ov_cimguiname": "ImChunkStream_begin",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_chunk_size": [
+    {
+      "args": "(ImChunkStream* self,const T* p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        },
+        {
+          "name": "p",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* p)",
+      "call_args": "(p)",
+      "cimguiname": "ImChunkStream_chunk_size",
+      "defaults": {},
+      "funcname": "chunk_size",
+      "location": "imgui_internal:725",
+      "ov_cimguiname": "ImChunkStream_chunk_size",
+      "ret": "int",
+      "signature": "(const T*)",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_clear": [
+    {
+      "args": "(ImChunkStream* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImChunkStream_clear",
+      "defaults": {},
+      "funcname": "clear",
+      "location": "imgui_internal:719",
+      "ov_cimguiname": "ImChunkStream_clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_empty": [
+    {
+      "args": "(ImChunkStream* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImChunkStream_empty",
+      "defaults": {},
+      "funcname": "empty",
+      "location": "imgui_internal:720",
+      "ov_cimguiname": "ImChunkStream_empty",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_end": [
+    {
+      "args": "(ImChunkStream* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImChunkStream_end",
+      "defaults": {},
+      "funcname": "end",
+      "location": "imgui_internal:726",
+      "ov_cimguiname": "ImChunkStream_end",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_next_chunk": [
+    {
+      "args": "(ImChunkStream* self,T* p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        },
+        {
+          "name": "p",
+          "type": "T*"
+        }
+      ],
+      "argsoriginal": "(T* p)",
+      "call_args": "(p)",
+      "cimguiname": "ImChunkStream_next_chunk",
+      "defaults": {},
+      "funcname": "next_chunk",
+      "location": "imgui_internal:724",
+      "ov_cimguiname": "ImChunkStream_next_chunk",
+      "ret": "T*",
+      "signature": "(T*)",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_offset_from_ptr": [
+    {
+      "args": "(ImChunkStream* self,const T* p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        },
+        {
+          "name": "p",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* p)",
+      "call_args": "(p)",
+      "cimguiname": "ImChunkStream_offset_from_ptr",
+      "defaults": {},
+      "funcname": "offset_from_ptr",
+      "location": "imgui_internal:727",
+      "ov_cimguiname": "ImChunkStream_offset_from_ptr",
+      "ret": "int",
+      "signature": "(const T*)",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_ptr_from_offset": [
+    {
+      "args": "(ImChunkStream* self,int off)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        },
+        {
+          "name": "off",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int off)",
+      "call_args": "(off)",
+      "cimguiname": "ImChunkStream_ptr_from_offset",
+      "defaults": {},
+      "funcname": "ptr_from_offset",
+      "location": "imgui_internal:728",
+      "ov_cimguiname": "ImChunkStream_ptr_from_offset",
+      "ret": "T*",
+      "signature": "(int)",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_size": [
+    {
+      "args": "(ImChunkStream* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImChunkStream_size",
+      "defaults": {},
+      "funcname": "size",
+      "location": "imgui_internal:721",
+      "ov_cimguiname": "ImChunkStream_size",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImChunkStream_swap": [
+    {
+      "args": "(ImChunkStream* self,ImChunkStream_T * rhs)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImChunkStream*"
+        },
+        {
+          "name": "rhs",
+          "reftoptr": true,
+          "type": "ImChunkStream_T *"
+        }
+      ],
+      "argsoriginal": "(ImChunkStream<T>& rhs)",
+      "call_args": "(*rhs)",
+      "cimguiname": "ImChunkStream_swap",
+      "defaults": {},
+      "funcname": "swap",
+      "location": "imgui_internal:729",
+      "ov_cimguiname": "ImChunkStream_swap",
+      "ret": "void",
+      "signature": "(ImChunkStream_T *)",
+      "stname": "ImChunkStream",
+      "templated": true
+    }
+  ],
+  "ImColor_HSV": [
+    {
+      "args": "(ImColor *pOut,float h,float s,float v,float a)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImColor*"
+        },
+        {
+          "name": "h",
+          "type": "float"
+        },
+        {
+          "name": "s",
+          "type": "float"
+        },
+        {
+          "name": "v",
+          "type": "float"
+        },
+        {
+          "name": "a",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float h,float s,float v,float a=1.0f)",
+      "call_args": "(h,s,v,a)",
+      "cimguiname": "ImColor_HSV",
+      "defaults": {
+        "a": "1.0f"
+      },
+      "funcname": "HSV",
+      "is_static_function": true,
+      "location": "imgui:2876",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImColor_HSV",
+      "ret": "void",
+      "signature": "(float,float,float,float)",
+      "stname": "ImColor"
+    }
+  ],
+  "ImColor_ImColor": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImColor_ImColor",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImColor",
+      "location": "imgui:2866",
+      "ov_cimguiname": "ImColor_ImColor_Nil",
+      "signature": "()",
+      "stname": "ImColor"
+    },
+    {
+      "args": "(float r,float g,float b,float a)",
+      "argsT": [
+        {
+          "name": "r",
+          "type": "float"
+        },
+        {
+          "name": "g",
+          "type": "float"
+        },
+        {
+          "name": "b",
+          "type": "float"
+        },
+        {
+          "name": "a",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float r,float g,float b,float a=1.0f)",
+      "call_args": "(r,g,b,a)",
+      "cimguiname": "ImColor_ImColor",
+      "constructor": true,
+      "defaults": {
+        "a": "1.0f"
+      },
+      "funcname": "ImColor",
+      "location": "imgui:2867",
+      "ov_cimguiname": "ImColor_ImColor_Float",
+      "signature": "(float,float,float,float)",
+      "stname": "ImColor"
+    },
+    {
+      "args": "(const ImVec4 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col)",
+      "call_args": "(col)",
+      "cimguiname": "ImColor_ImColor",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImColor",
+      "location": "imgui:2868",
+      "ov_cimguiname": "ImColor_ImColor_Vec4",
+      "signature": "(const ImVec4)",
+      "stname": "ImColor"
+    },
+    {
+      "args": "(int r,int g,int b,int a)",
+      "argsT": [
+        {
+          "name": "r",
+          "type": "int"
+        },
+        {
+          "name": "g",
+          "type": "int"
+        },
+        {
+          "name": "b",
+          "type": "int"
+        },
+        {
+          "name": "a",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int r,int g,int b,int a=255)",
+      "call_args": "(r,g,b,a)",
+      "cimguiname": "ImColor_ImColor",
+      "constructor": true,
+      "defaults": {
+        "a": "255"
+      },
+      "funcname": "ImColor",
+      "location": "imgui:2869",
+      "ov_cimguiname": "ImColor_ImColor_Int",
+      "signature": "(int,int,int,int)",
+      "stname": "ImColor"
+    },
+    {
+      "args": "(ImU32 rgba)",
+      "argsT": [
+        {
+          "name": "rgba",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 rgba)",
+      "call_args": "(rgba)",
+      "cimguiname": "ImColor_ImColor",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImColor",
+      "location": "imgui:2870",
+      "ov_cimguiname": "ImColor_ImColor_U32",
+      "signature": "(ImU32)",
+      "stname": "ImColor"
+    }
+  ],
+  "ImColor_SetHSV": [
+    {
+      "args": "(ImColor* self,float h,float s,float v,float a)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImColor*"
+        },
+        {
+          "name": "h",
+          "type": "float"
+        },
+        {
+          "name": "s",
+          "type": "float"
+        },
+        {
+          "name": "v",
+          "type": "float"
+        },
+        {
+          "name": "a",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float h,float s,float v,float a=1.0f)",
+      "call_args": "(h,s,v,a)",
+      "cimguiname": "ImColor_SetHSV",
+      "defaults": {
+        "a": "1.0f"
+      },
+      "funcname": "SetHSV",
+      "location": "imgui:2875",
+      "ov_cimguiname": "ImColor_SetHSV",
+      "ret": "void",
+      "signature": "(float,float,float,float)",
+      "stname": "ImColor"
+    }
+  ],
+  "ImColor_destroy": [
+    {
+      "args": "(ImColor* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImColor*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImColor_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2866",
+      "ov_cimguiname": "ImColor_destroy",
+      "ret": "void",
+      "signature": "(ImColor*)",
+      "stname": "ImColor"
+    }
+  ],
+  "ImDrawCmd_GetTexID": [
+    {
+      "args": "(ImDrawCmd* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawCmd*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawCmd_GetTexID",
+      "defaults": {},
+      "funcname": "GetTexID",
+      "location": "imgui:3074",
+      "ov_cimguiname": "ImDrawCmd_GetTexID",
+      "ret": "ImTextureID",
+      "signature": "()const",
+      "stname": "ImDrawCmd"
+    }
+  ],
+  "ImDrawCmd_ImDrawCmd": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawCmd_ImDrawCmd",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImDrawCmd",
+      "location": "imgui:3071",
+      "ov_cimguiname": "ImDrawCmd_ImDrawCmd",
+      "signature": "()",
+      "stname": "ImDrawCmd"
+    }
+  ],
+  "ImDrawCmd_destroy": [
+    {
+      "args": "(ImDrawCmd* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawCmd*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImDrawCmd_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3071",
+      "ov_cimguiname": "ImDrawCmd_destroy",
+      "ret": "void",
+      "signature": "(ImDrawCmd*)",
+      "stname": "ImDrawCmd"
+    }
+  ],
+  "ImDrawDataBuilder_ImDrawDataBuilder": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawDataBuilder_ImDrawDataBuilder",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImDrawDataBuilder",
+      "location": "imgui_internal:808",
+      "ov_cimguiname": "ImDrawDataBuilder_ImDrawDataBuilder",
+      "signature": "()",
+      "stname": "ImDrawDataBuilder"
+    }
+  ],
+  "ImDrawDataBuilder_destroy": [
+    {
+      "args": "(ImDrawDataBuilder* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawDataBuilder*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImDrawDataBuilder_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:808",
+      "ov_cimguiname": "ImDrawDataBuilder_destroy",
+      "ret": "void",
+      "signature": "(ImDrawDataBuilder*)",
+      "stname": "ImDrawDataBuilder"
+    }
+  ],
+  "ImDrawData_AddDrawList": [
+    {
+      "args": "(ImDrawData* self,ImDrawList* draw_list)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawData*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list)",
+      "call_args": "(draw_list)",
+      "cimguiname": "ImDrawData_AddDrawList",
+      "defaults": {},
+      "funcname": "AddDrawList",
+      "location": "imgui:3334",
+      "ov_cimguiname": "ImDrawData_AddDrawList",
+      "ret": "void",
+      "signature": "(ImDrawList*)",
+      "stname": "ImDrawData"
+    }
+  ],
+  "ImDrawData_Clear": [
+    {
+      "args": "(ImDrawData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawData_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:3333",
+      "ov_cimguiname": "ImDrawData_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawData"
+    }
+  ],
+  "ImDrawData_DeIndexAllBuffers": [
+    {
+      "args": "(ImDrawData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawData_DeIndexAllBuffers",
+      "defaults": {},
+      "funcname": "DeIndexAllBuffers",
+      "location": "imgui:3335",
+      "ov_cimguiname": "ImDrawData_DeIndexAllBuffers",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawData"
+    }
+  ],
+  "ImDrawData_ImDrawData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawData_ImDrawData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImDrawData",
+      "location": "imgui:3332",
+      "ov_cimguiname": "ImDrawData_ImDrawData",
+      "signature": "()",
+      "stname": "ImDrawData"
+    }
+  ],
+  "ImDrawData_ScaleClipRects": [
+    {
+      "args": "(ImDrawData* self,const ImVec2 fb_scale)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawData*"
+        },
+        {
+          "name": "fb_scale",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& fb_scale)",
+      "call_args": "(fb_scale)",
+      "cimguiname": "ImDrawData_ScaleClipRects",
+      "defaults": {},
+      "funcname": "ScaleClipRects",
+      "location": "imgui:3336",
+      "ov_cimguiname": "ImDrawData_ScaleClipRects",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImDrawData"
+    }
+  ],
+  "ImDrawData_destroy": [
+    {
+      "args": "(ImDrawData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImDrawData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3332",
+      "ov_cimguiname": "ImDrawData_destroy",
+      "ret": "void",
+      "signature": "(ImDrawData*)",
+      "stname": "ImDrawData"
+    }
+  ],
+  "ImDrawListSharedData_ImDrawListSharedData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawListSharedData_ImDrawListSharedData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImDrawListSharedData",
+      "location": "imgui_internal:799",
+      "ov_cimguiname": "ImDrawListSharedData_ImDrawListSharedData",
+      "signature": "()",
+      "stname": "ImDrawListSharedData"
+    }
+  ],
+  "ImDrawListSharedData_SetCircleTessellationMaxError": [
+    {
+      "args": "(ImDrawListSharedData* self,float max_error)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSharedData*"
+        },
+        {
+          "name": "max_error",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float max_error)",
+      "call_args": "(max_error)",
+      "cimguiname": "ImDrawListSharedData_SetCircleTessellationMaxError",
+      "defaults": {},
+      "funcname": "SetCircleTessellationMaxError",
+      "location": "imgui_internal:800",
+      "ov_cimguiname": "ImDrawListSharedData_SetCircleTessellationMaxError",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": "ImDrawListSharedData"
+    }
+  ],
+  "ImDrawListSharedData_destroy": [
+    {
+      "args": "(ImDrawListSharedData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSharedData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImDrawListSharedData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:799",
+      "ov_cimguiname": "ImDrawListSharedData_destroy",
+      "ret": "void",
+      "signature": "(ImDrawListSharedData*)",
+      "stname": "ImDrawListSharedData"
+    }
+  ],
+  "ImDrawListSplitter_Clear": [
+    {
+      "args": "(ImDrawListSplitter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSplitter*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawListSplitter_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:3119",
+      "ov_cimguiname": "ImDrawListSplitter_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawListSplitter_ClearFreeMemory": [
+    {
+      "args": "(ImDrawListSplitter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSplitter*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawListSplitter_ClearFreeMemory",
+      "defaults": {},
+      "funcname": "ClearFreeMemory",
+      "location": "imgui:3120",
+      "ov_cimguiname": "ImDrawListSplitter_ClearFreeMemory",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawListSplitter_ImDrawListSplitter": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawListSplitter_ImDrawListSplitter",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImDrawListSplitter",
+      "location": "imgui:3117",
+      "ov_cimguiname": "ImDrawListSplitter_ImDrawListSplitter",
+      "signature": "()",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawListSplitter_Merge": [
+    {
+      "args": "(ImDrawListSplitter* self,ImDrawList* draw_list)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSplitter*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list)",
+      "call_args": "(draw_list)",
+      "cimguiname": "ImDrawListSplitter_Merge",
+      "defaults": {},
+      "funcname": "Merge",
+      "location": "imgui:3122",
+      "ov_cimguiname": "ImDrawListSplitter_Merge",
+      "ret": "void",
+      "signature": "(ImDrawList*)",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawListSplitter_SetCurrentChannel": [
+    {
+      "args": "(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSplitter*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "channel_idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,int channel_idx)",
+      "call_args": "(draw_list,channel_idx)",
+      "cimguiname": "ImDrawListSplitter_SetCurrentChannel",
+      "defaults": {},
+      "funcname": "SetCurrentChannel",
+      "location": "imgui:3123",
+      "ov_cimguiname": "ImDrawListSplitter_SetCurrentChannel",
+      "ret": "void",
+      "signature": "(ImDrawList*,int)",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawListSplitter_Split": [
+    {
+      "args": "(ImDrawListSplitter* self,ImDrawList* draw_list,int count)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSplitter*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,int count)",
+      "call_args": "(draw_list,count)",
+      "cimguiname": "ImDrawListSplitter_Split",
+      "defaults": {},
+      "funcname": "Split",
+      "location": "imgui:3121",
+      "ov_cimguiname": "ImDrawListSplitter_Split",
+      "ret": "void",
+      "signature": "(ImDrawList*,int)",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawListSplitter_destroy": [
+    {
+      "args": "(ImDrawListSplitter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawListSplitter*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImDrawListSplitter_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3118",
+      "ov_cimguiname": "ImDrawListSplitter_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImDrawListSplitter*)",
+      "stname": "ImDrawListSplitter"
+    }
+  ],
+  "ImDrawList_AddBezierCubic": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,ImU32 col,float thickness,int num_segments=0)",
+      "call_args": "(p1,p2,p3,p4,col,thickness,num_segments)",
+      "cimguiname": "ImDrawList_AddBezierCubic",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "AddBezierCubic",
+      "location": "imgui:3224",
+      "ov_cimguiname": "ImDrawList_AddBezierCubic",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddBezierQuadratic": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,ImU32 col,float thickness,int num_segments=0)",
+      "call_args": "(p1,p2,p3,col,thickness,num_segments)",
+      "cimguiname": "ImDrawList_AddBezierQuadratic",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "AddBezierQuadratic",
+      "location": "imgui:3225",
+      "ov_cimguiname": "ImDrawList_AddBezierQuadratic",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,ImU32,float,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddCallback": [
+    {
+      "args": "(ImDrawList* self,ImDrawCallback callback,void* userdata,size_t userdata_size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "callback",
+          "type": "ImDrawCallback"
+        },
+        {
+          "name": "userdata",
+          "type": "void*"
+        },
+        {
+          "name": "userdata_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(ImDrawCallback callback,void* userdata,size_t userdata_size=0)",
+      "call_args": "(callback,userdata,userdata_size)",
+      "cimguiname": "ImDrawList_AddCallback",
+      "defaults": {
+        "userdata_size": "0"
+      },
+      "funcname": "AddCallback",
+      "location": "imgui:3267",
+      "ov_cimguiname": "ImDrawList_AddCallback",
+      "ret": "void",
+      "signature": "(ImDrawCallback,void*,size_t)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddCircle": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,ImU32 col,int num_segments=0,float thickness=1.0f)",
+      "call_args": "(center,radius,col,num_segments,thickness)",
+      "cimguiname": "ImDrawList_AddCircle",
+      "defaults": {
+        "num_segments": "0",
+        "thickness": "1.0f"
+      },
+      "funcname": "AddCircle",
+      "location": "imgui:3216",
+      "ov_cimguiname": "ImDrawList_AddCircle",
+      "ret": "void",
+      "signature": "(const ImVec2,float,ImU32,int,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddCircleFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,ImU32 col,int num_segments=0)",
+      "call_args": "(center,radius,col,num_segments)",
+      "cimguiname": "ImDrawList_AddCircleFilled",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "AddCircleFilled",
+      "location": "imgui:3217",
+      "ov_cimguiname": "ImDrawList_AddCircleFilled",
+      "ret": "void",
+      "signature": "(const ImVec2,float,ImU32,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddConcavePolyFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "points",
+          "type": "const ImVec2*"
+        },
+        {
+          "name": "num_points",
+          "type": "int"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2* points,int num_points,ImU32 col)",
+      "call_args": "(points,num_points,col)",
+      "cimguiname": "ImDrawList_AddConcavePolyFilled",
+      "defaults": {},
+      "funcname": "AddConcavePolyFilled",
+      "location": "imgui:3232",
+      "ov_cimguiname": "ImDrawList_AddConcavePolyFilled",
+      "ret": "void",
+      "signature": "(const ImVec2*,int,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddConvexPolyFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "points",
+          "type": "const ImVec2*"
+        },
+        {
+          "name": "num_points",
+          "type": "int"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2* points,int num_points,ImU32 col)",
+      "call_args": "(points,num_points,col)",
+      "cimguiname": "ImDrawList_AddConvexPolyFilled",
+      "defaults": {},
+      "funcname": "AddConvexPolyFilled",
+      "location": "imgui:3231",
+      "ov_cimguiname": "ImDrawList_AddConvexPolyFilled",
+      "ret": "void",
+      "signature": "(const ImVec2*,int,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddDrawCmd": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_AddDrawCmd",
+      "defaults": {},
+      "funcname": "AddDrawCmd",
+      "location": "imgui:3270",
+      "ov_cimguiname": "ImDrawList_AddDrawCmd",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddEllipse": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,const ImVec2 radius,ImU32 col,float rot,int num_segments,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "rot",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,const ImVec2& radius,ImU32 col,float rot=0.0f,int num_segments=0,float thickness=1.0f)",
+      "call_args": "(center,radius,col,rot,num_segments,thickness)",
+      "cimguiname": "ImDrawList_AddEllipse",
+      "defaults": {
+        "num_segments": "0",
+        "rot": "0.0f",
+        "thickness": "1.0f"
+      },
+      "funcname": "AddEllipse",
+      "location": "imgui:3220",
+      "ov_cimguiname": "ImDrawList_AddEllipse",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,float,int,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddEllipseFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,const ImVec2 radius,ImU32 col,float rot,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "rot",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,const ImVec2& radius,ImU32 col,float rot=0.0f,int num_segments=0)",
+      "call_args": "(center,radius,col,rot,num_segments)",
+      "cimguiname": "ImDrawList_AddEllipseFilled",
+      "defaults": {
+        "num_segments": "0",
+        "rot": "0.0f"
+      },
+      "funcname": "AddEllipseFilled",
+      "location": "imgui:3221",
+      "ov_cimguiname": "ImDrawList_AddEllipseFilled",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,float,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddImage": [
+    {
+      "args": "(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "p_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& p_min,const ImVec2& p_max,const ImVec2& uv_min=ImVec2(0,0),const ImVec2& uv_max=ImVec2(1,1),ImU32 col=(((ImU32)(255)<<24)|((ImU32)(255)<<16)|((ImU32)(255)<<8)|((ImU32)(255)<<0)))",
+      "call_args": "(user_texture_id,p_min,p_max,uv_min,uv_max,col)",
+      "cimguiname": "ImDrawList_AddImage",
+      "defaults": {
+        "col": "4294967295",
+        "uv_max": "ImVec2(1,1)",
+        "uv_min": "ImVec2(0,0)"
+      },
+      "funcname": "AddImage",
+      "location": "imgui:3238",
+      "ov_cimguiname": "ImDrawList_AddImage",
+      "ret": "void",
+      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddImageQuad": [
+    {
+      "args": "(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 uv1,const ImVec2 uv2,const ImVec2 uv3,const ImVec2 uv4,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,const ImVec2& uv1=ImVec2(0,0),const ImVec2& uv2=ImVec2(1,0),const ImVec2& uv3=ImVec2(1,1),const ImVec2& uv4=ImVec2(0,1),ImU32 col=(((ImU32)(255)<<24)|((ImU32)(255)<<16)|((ImU32)(255)<<8)|((ImU32)(255)<<0)))",
+      "call_args": "(user_texture_id,p1,p2,p3,p4,uv1,uv2,uv3,uv4,col)",
+      "cimguiname": "ImDrawList_AddImageQuad",
+      "defaults": {
+        "col": "4294967295",
+        "uv1": "ImVec2(0,0)",
+        "uv2": "ImVec2(1,0)",
+        "uv3": "ImVec2(1,1)",
+        "uv4": "ImVec2(0,1)"
+      },
+      "funcname": "AddImageQuad",
+      "location": "imgui:3239",
+      "ov_cimguiname": "ImDrawList_AddImageQuad",
+      "ret": "void",
+      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddImageRounded": [
+    {
+      "args": "(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 p_min,const ImVec2 p_max,const ImVec2 uv_min,const ImVec2 uv_max,ImU32 col,float rounding,ImDrawFlags flags)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "p_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        }
+      ],
+      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& p_min,const ImVec2& p_max,const ImVec2& uv_min,const ImVec2& uv_max,ImU32 col,float rounding,ImDrawFlags flags=0)",
+      "call_args": "(user_texture_id,p_min,p_max,uv_min,uv_max,col,rounding,flags)",
+      "cimguiname": "ImDrawList_AddImageRounded",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "AddImageRounded",
+      "location": "imgui:3240",
+      "ov_cimguiname": "ImDrawList_AddImageRounded",
+      "ret": "void",
+      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float,ImDrawFlags)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddLine": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,ImU32 col,float thickness=1.0f)",
+      "call_args": "(p1,p2,col,thickness)",
+      "cimguiname": "ImDrawList_AddLine",
+      "defaults": {
+        "thickness": "1.0f"
+      },
+      "funcname": "AddLine",
+      "location": "imgui:3208",
+      "ov_cimguiname": "ImDrawList_AddLine",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddNgon": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,ImU32 col,int num_segments,float thickness=1.0f)",
+      "call_args": "(center,radius,col,num_segments,thickness)",
+      "cimguiname": "ImDrawList_AddNgon",
+      "defaults": {
+        "thickness": "1.0f"
+      },
+      "funcname": "AddNgon",
+      "location": "imgui:3218",
+      "ov_cimguiname": "ImDrawList_AddNgon",
+      "ret": "void",
+      "signature": "(const ImVec2,float,ImU32,int,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddNgonFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,ImU32 col,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,ImU32 col,int num_segments)",
+      "call_args": "(center,radius,col,num_segments)",
+      "cimguiname": "ImDrawList_AddNgonFilled",
+      "defaults": {},
+      "funcname": "AddNgonFilled",
+      "location": "imgui:3219",
+      "ov_cimguiname": "ImDrawList_AddNgonFilled",
+      "ret": "void",
+      "signature": "(const ImVec2,float,ImU32,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddPolyline": [
+    {
+      "args": "(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col,ImDrawFlags flags,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "points",
+          "type": "const ImVec2*"
+        },
+        {
+          "name": "num_points",
+          "type": "int"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2* points,int num_points,ImU32 col,ImDrawFlags flags,float thickness)",
+      "call_args": "(points,num_points,col,flags,thickness)",
+      "cimguiname": "ImDrawList_AddPolyline",
+      "defaults": {},
+      "funcname": "AddPolyline",
+      "location": "imgui:3230",
+      "ov_cimguiname": "ImDrawList_AddPolyline",
+      "ret": "void",
+      "signature": "(const ImVec2*,int,ImU32,ImDrawFlags,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddQuad": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,ImU32 col,float thickness=1.0f)",
+      "call_args": "(p1,p2,p3,p4,col,thickness)",
+      "cimguiname": "ImDrawList_AddQuad",
+      "defaults": {
+        "thickness": "1.0f"
+      },
+      "funcname": "AddQuad",
+      "location": "imgui:3212",
+      "ov_cimguiname": "ImDrawList_AddQuad",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddQuadFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,ImU32 col)",
+      "call_args": "(p1,p2,p3,p4,col)",
+      "cimguiname": "ImDrawList_AddQuadFilled",
+      "defaults": {},
+      "funcname": "AddQuadFilled",
+      "location": "imgui:3213",
+      "ov_cimguiname": "ImDrawList_AddQuadFilled",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddRect": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p_min,const ImVec2& p_max,ImU32 col,float rounding=0.0f,ImDrawFlags flags=0,float thickness=1.0f)",
+      "call_args": "(p_min,p_max,col,rounding,flags,thickness)",
+      "cimguiname": "ImDrawList_AddRect",
+      "defaults": {
+        "flags": "0",
+        "rounding": "0.0f",
+        "thickness": "1.0f"
+      },
+      "funcname": "AddRect",
+      "location": "imgui:3209",
+      "ov_cimguiname": "ImDrawList_AddRect",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,float,ImDrawFlags,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddRectFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p_min,const ImVec2& p_max,ImU32 col,float rounding=0.0f,ImDrawFlags flags=0)",
+      "call_args": "(p_min,p_max,col,rounding,flags)",
+      "cimguiname": "ImDrawList_AddRectFilled",
+      "defaults": {
+        "flags": "0",
+        "rounding": "0.0f"
+      },
+      "funcname": "AddRectFilled",
+      "location": "imgui:3210",
+      "ov_cimguiname": "ImDrawList_AddRectFilled",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,float,ImDrawFlags)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddRectFilledMultiColor": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col_upr_left",
+          "type": "ImU32"
+        },
+        {
+          "name": "col_upr_right",
+          "type": "ImU32"
+        },
+        {
+          "name": "col_bot_right",
+          "type": "ImU32"
+        },
+        {
+          "name": "col_bot_left",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p_min,const ImVec2& p_max,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left)",
+      "call_args": "(p_min,p_max,col_upr_left,col_upr_right,col_bot_right,col_bot_left)",
+      "cimguiname": "ImDrawList_AddRectFilledMultiColor",
+      "defaults": {},
+      "funcname": "AddRectFilledMultiColor",
+      "location": "imgui:3211",
+      "ov_cimguiname": "ImDrawList_AddRectFilledMultiColor",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,ImU32,ImU32,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddText": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "text_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,ImU32 col,const char* text_begin,const char* text_end=((void*)0))",
+      "call_args": "(pos,col,text_begin,text_end)",
+      "cimguiname": "ImDrawList_AddText",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "AddText",
+      "location": "imgui:3222",
+      "ov_cimguiname": "ImDrawList_AddText_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2,ImU32,const char*,const char*)",
+      "stname": "ImDrawList"
+    },
+    {
+      "args": "(ImDrawList* self,ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "font",
+          "type": "ImFont*"
+        },
+        {
+          "name": "font_size",
+          "type": "float"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "text_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "wrap_width",
+          "type": "float"
+        },
+        {
+          "name": "cpu_fine_clip_rect",
+          "type": "const ImVec4*"
+        }
+      ],
+      "argsoriginal": "(ImFont* font,float font_size,const ImVec2& pos,ImU32 col,const char* text_begin,const char* text_end=((void*)0),float wrap_width=0.0f,const ImVec4* cpu_fine_clip_rect=((void*)0))",
+      "call_args": "(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect)",
+      "cimguiname": "ImDrawList_AddText",
+      "defaults": {
+        "cpu_fine_clip_rect": "NULL",
+        "text_end": "NULL",
+        "wrap_width": "0.0f"
+      },
+      "funcname": "AddText",
+      "location": "imgui:3223",
+      "ov_cimguiname": "ImDrawList_AddText_FontPtr",
+      "ret": "void",
+      "signature": "(ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddTriangle": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,ImU32 col,float thickness=1.0f)",
+      "call_args": "(p1,p2,p3,col,thickness)",
+      "cimguiname": "ImDrawList_AddTriangle",
+      "defaults": {
+        "thickness": "1.0f"
+      },
+      "funcname": "AddTriangle",
+      "location": "imgui:3214",
+      "ov_cimguiname": "ImDrawList_AddTriangle",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,ImU32,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_AddTriangleFilled": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,ImU32 col)",
+      "call_args": "(p1,p2,p3,col)",
+      "cimguiname": "ImDrawList_AddTriangleFilled",
+      "defaults": {},
+      "funcname": "AddTriangleFilled",
+      "location": "imgui:3215",
+      "ov_cimguiname": "ImDrawList_AddTriangleFilled",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_ChannelsMerge": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_ChannelsMerge",
+      "defaults": {},
+      "funcname": "ChannelsMerge",
+      "location": "imgui:3280",
+      "ov_cimguiname": "ImDrawList_ChannelsMerge",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_ChannelsSetCurrent": [
+    {
+      "args": "(ImDrawList* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImDrawList_ChannelsSetCurrent",
+      "defaults": {},
+      "funcname": "ChannelsSetCurrent",
+      "location": "imgui:3281",
+      "ov_cimguiname": "ImDrawList_ChannelsSetCurrent",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_ChannelsSplit": [
+    {
+      "args": "(ImDrawList* self,int count)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int count)",
+      "call_args": "(count)",
+      "cimguiname": "ImDrawList_ChannelsSplit",
+      "defaults": {},
+      "funcname": "ChannelsSplit",
+      "location": "imgui:3279",
+      "ov_cimguiname": "ImDrawList_ChannelsSplit",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_CloneOutput": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_CloneOutput",
+      "defaults": {},
+      "funcname": "CloneOutput",
+      "location": "imgui:3271",
+      "ov_cimguiname": "ImDrawList_CloneOutput",
+      "ret": "ImDrawList*",
+      "signature": "()const",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_GetClipRectMax": [
+    {
+      "args": "(ImVec2 *pOut,ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_GetClipRectMax",
+      "defaults": {},
+      "funcname": "GetClipRectMax",
+      "location": "imgui:3199",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImDrawList_GetClipRectMax",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_GetClipRectMin": [
+    {
+      "args": "(ImVec2 *pOut,ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_GetClipRectMin",
+      "defaults": {},
+      "funcname": "GetClipRectMin",
+      "location": "imgui:3198",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImDrawList_GetClipRectMin",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_ImDrawList": [
+    {
+      "args": "(ImDrawListSharedData* shared_data)",
+      "argsT": [
+        {
+          "name": "shared_data",
+          "type": "ImDrawListSharedData*"
+        }
+      ],
+      "argsoriginal": "(ImDrawListSharedData* shared_data)",
+      "call_args": "(shared_data)",
+      "cimguiname": "ImDrawList_ImDrawList",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImDrawList",
+      "location": "imgui:3190",
+      "ov_cimguiname": "ImDrawList_ImDrawList",
+      "signature": "(ImDrawListSharedData*)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathArcTo": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "a_min",
+          "type": "float"
+        },
+        {
+          "name": "a_max",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,float a_min,float a_max,int num_segments=0)",
+      "call_args": "(center,radius,a_min,a_max,num_segments)",
+      "cimguiname": "ImDrawList_PathArcTo",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "PathArcTo",
+      "location": "imgui:3251",
+      "ov_cimguiname": "ImDrawList_PathArcTo",
+      "ret": "void",
+      "signature": "(const ImVec2,float,float,float,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathArcToFast": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,int a_min_of_12,int a_max_of_12)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "a_min_of_12",
+          "type": "int"
+        },
+        {
+          "name": "a_max_of_12",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,int a_min_of_12,int a_max_of_12)",
+      "call_args": "(center,radius,a_min_of_12,a_max_of_12)",
+      "cimguiname": "ImDrawList_PathArcToFast",
+      "defaults": {},
+      "funcname": "PathArcToFast",
+      "location": "imgui:3252",
+      "ov_cimguiname": "ImDrawList_PathArcToFast",
+      "ret": "void",
+      "signature": "(const ImVec2,float,int,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathBezierCubicCurveTo": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,int num_segments=0)",
+      "call_args": "(p2,p3,p4,num_segments)",
+      "cimguiname": "ImDrawList_PathBezierCubicCurveTo",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "PathBezierCubicCurveTo",
+      "location": "imgui:3254",
+      "ov_cimguiname": "ImDrawList_PathBezierCubicCurveTo",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathBezierQuadraticCurveTo": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 p2,const ImVec2 p3,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p2,const ImVec2& p3,int num_segments=0)",
+      "call_args": "(p2,p3,num_segments)",
+      "cimguiname": "ImDrawList_PathBezierQuadraticCurveTo",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "PathBezierQuadraticCurveTo",
+      "location": "imgui:3255",
+      "ov_cimguiname": "ImDrawList_PathBezierQuadraticCurveTo",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathClear": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_PathClear",
+      "defaults": {},
+      "funcname": "PathClear",
+      "location": "imgui:3245",
+      "ov_cimguiname": "ImDrawList_PathClear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathEllipticalArcTo": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,const ImVec2 radius,float rot,float a_min,float a_max,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rot",
+          "type": "float"
+        },
+        {
+          "name": "a_min",
+          "type": "float"
+        },
+        {
+          "name": "a_max",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,const ImVec2& radius,float rot,float a_min,float a_max,int num_segments=0)",
+      "call_args": "(center,radius,rot,a_min,a_max,num_segments)",
+      "cimguiname": "ImDrawList_PathEllipticalArcTo",
+      "defaults": {
+        "num_segments": "0"
+      },
+      "funcname": "PathEllipticalArcTo",
+      "location": "imgui:3253",
+      "ov_cimguiname": "ImDrawList_PathEllipticalArcTo",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,float,float,float,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathFillConcave": [
+    {
+      "args": "(ImDrawList* self,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col)",
+      "call_args": "(col)",
+      "cimguiname": "ImDrawList_PathFillConcave",
+      "defaults": {},
+      "funcname": "PathFillConcave",
+      "location": "imgui:3249",
+      "ov_cimguiname": "ImDrawList_PathFillConcave",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathFillConvex": [
+    {
+      "args": "(ImDrawList* self,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col)",
+      "call_args": "(col)",
+      "cimguiname": "ImDrawList_PathFillConvex",
+      "defaults": {},
+      "funcname": "PathFillConvex",
+      "location": "imgui:3248",
+      "ov_cimguiname": "ImDrawList_PathFillConvex",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathLineTo": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos)",
+      "call_args": "(pos)",
+      "cimguiname": "ImDrawList_PathLineTo",
+      "defaults": {},
+      "funcname": "PathLineTo",
+      "location": "imgui:3246",
+      "ov_cimguiname": "ImDrawList_PathLineTo",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathLineToMergeDuplicate": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos)",
+      "call_args": "(pos)",
+      "cimguiname": "ImDrawList_PathLineToMergeDuplicate",
+      "defaults": {},
+      "funcname": "PathLineToMergeDuplicate",
+      "location": "imgui:3247",
+      "ov_cimguiname": "ImDrawList_PathLineToMergeDuplicate",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathRect": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawFlags flags)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "rect_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rect_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& rect_min,const ImVec2& rect_max,float rounding=0.0f,ImDrawFlags flags=0)",
+      "call_args": "(rect_min,rect_max,rounding,flags)",
+      "cimguiname": "ImDrawList_PathRect",
+      "defaults": {
+        "flags": "0",
+        "rounding": "0.0f"
+      },
+      "funcname": "PathRect",
+      "location": "imgui:3256",
+      "ov_cimguiname": "ImDrawList_PathRect",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,float,ImDrawFlags)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PathStroke": [
+    {
+      "args": "(ImDrawList* self,ImU32 col,ImDrawFlags flags,float thickness)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImU32 col,ImDrawFlags flags=0,float thickness=1.0f)",
+      "call_args": "(col,flags,thickness)",
+      "cimguiname": "ImDrawList_PathStroke",
+      "defaults": {
+        "flags": "0",
+        "thickness": "1.0f"
+      },
+      "funcname": "PathStroke",
+      "location": "imgui:3250",
+      "ov_cimguiname": "ImDrawList_PathStroke",
+      "ret": "void",
+      "signature": "(ImU32,ImDrawFlags,float)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PopClipRect": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_PopClipRect",
+      "defaults": {},
+      "funcname": "PopClipRect",
+      "location": "imgui:3195",
+      "ov_cimguiname": "ImDrawList_PopClipRect",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PopTextureID": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_PopTextureID",
+      "defaults": {},
+      "funcname": "PopTextureID",
+      "location": "imgui:3197",
+      "ov_cimguiname": "ImDrawList_PopTextureID",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimQuadUV": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "c",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "d",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_c",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_d",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& d,const ImVec2& uv_a,const ImVec2& uv_b,const ImVec2& uv_c,const ImVec2& uv_d,ImU32 col)",
+      "call_args": "(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col)",
+      "cimguiname": "ImDrawList_PrimQuadUV",
+      "defaults": {},
+      "funcname": "PrimQuadUV",
+      "location": "imgui:3290",
+      "ov_cimguiname": "ImDrawList_PrimQuadUV",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimRect": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,ImU32 col)",
+      "call_args": "(a,b,col)",
+      "cimguiname": "ImDrawList_PrimRect",
+      "defaults": {},
+      "funcname": "PrimRect",
+      "location": "imgui:3288",
+      "ov_cimguiname": "ImDrawList_PrimRect",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimRectUV": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& uv_a,const ImVec2& uv_b,ImU32 col)",
+      "call_args": "(a,b,uv_a,uv_b,col)",
+      "cimguiname": "ImDrawList_PrimRectUV",
+      "defaults": {},
+      "funcname": "PrimRectUV",
+      "location": "imgui:3289",
+      "ov_cimguiname": "ImDrawList_PrimRectUV",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimReserve": [
+    {
+      "args": "(ImDrawList* self,int idx_count,int vtx_count)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "idx_count",
+          "type": "int"
+        },
+        {
+          "name": "vtx_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int idx_count,int vtx_count)",
+      "call_args": "(idx_count,vtx_count)",
+      "cimguiname": "ImDrawList_PrimReserve",
+      "defaults": {},
+      "funcname": "PrimReserve",
+      "location": "imgui:3286",
+      "ov_cimguiname": "ImDrawList_PrimReserve",
+      "ret": "void",
+      "signature": "(int,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimUnreserve": [
+    {
+      "args": "(ImDrawList* self,int idx_count,int vtx_count)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "idx_count",
+          "type": "int"
+        },
+        {
+          "name": "vtx_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int idx_count,int vtx_count)",
+      "call_args": "(idx_count,vtx_count)",
+      "cimguiname": "ImDrawList_PrimUnreserve",
+      "defaults": {},
+      "funcname": "PrimUnreserve",
+      "location": "imgui:3287",
+      "ov_cimguiname": "ImDrawList_PrimUnreserve",
+      "ret": "void",
+      "signature": "(int,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimVtx": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,const ImVec2& uv,ImU32 col)",
+      "call_args": "(pos,uv,col)",
+      "cimguiname": "ImDrawList_PrimVtx",
+      "defaults": {},
+      "funcname": "PrimVtx",
+      "location": "imgui:3293",
+      "ov_cimguiname": "ImDrawList_PrimVtx",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimWriteIdx": [
+    {
+      "args": "(ImDrawList* self,ImDrawIdx idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "idx",
+          "type": "ImDrawIdx"
+        }
+      ],
+      "argsoriginal": "(ImDrawIdx idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImDrawList_PrimWriteIdx",
+      "defaults": {},
+      "funcname": "PrimWriteIdx",
+      "location": "imgui:3292",
+      "ov_cimguiname": "ImDrawList_PrimWriteIdx",
+      "ret": "void",
+      "signature": "(ImDrawIdx)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PrimWriteVtx": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,const ImVec2& uv,ImU32 col)",
+      "call_args": "(pos,uv,col)",
+      "cimguiname": "ImDrawList_PrimWriteVtx",
+      "defaults": {},
+      "funcname": "PrimWriteVtx",
+      "location": "imgui:3291",
+      "ov_cimguiname": "ImDrawList_PrimWriteVtx",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PushClipRect": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "clip_rect_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clip_rect_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "intersect_with_current_clip_rect",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& clip_rect_min,const ImVec2& clip_rect_max,bool intersect_with_current_clip_rect=false)",
+      "call_args": "(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect)",
+      "cimguiname": "ImDrawList_PushClipRect",
+      "defaults": {
+        "intersect_with_current_clip_rect": "false"
+      },
+      "funcname": "PushClipRect",
+      "location": "imgui:3193",
+      "ov_cimguiname": "ImDrawList_PushClipRect",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,bool)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PushClipRectFullScreen": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList_PushClipRectFullScreen",
+      "defaults": {},
+      "funcname": "PushClipRectFullScreen",
+      "location": "imgui:3194",
+      "ov_cimguiname": "ImDrawList_PushClipRectFullScreen",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_PushTextureID": [
+    {
+      "args": "(ImDrawList* self,ImTextureID texture_id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "texture_id",
+          "type": "ImTextureID"
+        }
+      ],
+      "argsoriginal": "(ImTextureID texture_id)",
+      "call_args": "(texture_id)",
+      "cimguiname": "ImDrawList_PushTextureID",
+      "defaults": {},
+      "funcname": "PushTextureID",
+      "location": "imgui:3196",
+      "ov_cimguiname": "ImDrawList_PushTextureID",
+      "ret": "void",
+      "signature": "(ImTextureID)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__CalcCircleAutoSegmentCount": [
+    {
+      "args": "(ImDrawList* self,float radius)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float radius)",
+      "call_args": "(radius)",
+      "cimguiname": "ImDrawList__CalcCircleAutoSegmentCount",
+      "defaults": {},
+      "funcname": "_CalcCircleAutoSegmentCount",
+      "location": "imgui:3311",
+      "ov_cimguiname": "ImDrawList__CalcCircleAutoSegmentCount",
+      "ret": "int",
+      "signature": "(float)const",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__ClearFreeMemory": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__ClearFreeMemory",
+      "defaults": {},
+      "funcname": "_ClearFreeMemory",
+      "location": "imgui:3304",
+      "ov_cimguiname": "ImDrawList__ClearFreeMemory",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__OnChangedClipRect": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__OnChangedClipRect",
+      "defaults": {},
+      "funcname": "_OnChangedClipRect",
+      "location": "imgui:3307",
+      "ov_cimguiname": "ImDrawList__OnChangedClipRect",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__OnChangedTextureID": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__OnChangedTextureID",
+      "defaults": {},
+      "funcname": "_OnChangedTextureID",
+      "location": "imgui:3308",
+      "ov_cimguiname": "ImDrawList__OnChangedTextureID",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__OnChangedVtxOffset": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__OnChangedVtxOffset",
+      "defaults": {},
+      "funcname": "_OnChangedVtxOffset",
+      "location": "imgui:3309",
+      "ov_cimguiname": "ImDrawList__OnChangedVtxOffset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__PathArcToFastEx": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,int a_min_sample,int a_max_sample,int a_step)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "a_min_sample",
+          "type": "int"
+        },
+        {
+          "name": "a_max_sample",
+          "type": "int"
+        },
+        {
+          "name": "a_step",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,int a_min_sample,int a_max_sample,int a_step)",
+      "call_args": "(center,radius,a_min_sample,a_max_sample,a_step)",
+      "cimguiname": "ImDrawList__PathArcToFastEx",
+      "defaults": {},
+      "funcname": "_PathArcToFastEx",
+      "location": "imgui:3312",
+      "ov_cimguiname": "ImDrawList__PathArcToFastEx",
+      "ret": "void",
+      "signature": "(const ImVec2,float,int,int,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__PathArcToN": [
+    {
+      "args": "(ImDrawList* self,const ImVec2 center,float radius,float a_min,float a_max,int num_segments)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "center",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "radius",
+          "type": "float"
+        },
+        {
+          "name": "a_min",
+          "type": "float"
+        },
+        {
+          "name": "a_max",
+          "type": "float"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& center,float radius,float a_min,float a_max,int num_segments)",
+      "call_args": "(center,radius,a_min,a_max,num_segments)",
+      "cimguiname": "ImDrawList__PathArcToN",
+      "defaults": {},
+      "funcname": "_PathArcToN",
+      "location": "imgui:3313",
+      "ov_cimguiname": "ImDrawList__PathArcToN",
+      "ret": "void",
+      "signature": "(const ImVec2,float,float,float,int)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__PopUnusedDrawCmd": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__PopUnusedDrawCmd",
+      "defaults": {},
+      "funcname": "_PopUnusedDrawCmd",
+      "location": "imgui:3305",
+      "ov_cimguiname": "ImDrawList__PopUnusedDrawCmd",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__ResetForNewFrame": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__ResetForNewFrame",
+      "defaults": {},
+      "funcname": "_ResetForNewFrame",
+      "location": "imgui:3303",
+      "ov_cimguiname": "ImDrawList__ResetForNewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__SetTextureID": [
+    {
+      "args": "(ImDrawList* self,ImTextureID texture_id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "texture_id",
+          "type": "ImTextureID"
+        }
+      ],
+      "argsoriginal": "(ImTextureID texture_id)",
+      "call_args": "(texture_id)",
+      "cimguiname": "ImDrawList__SetTextureID",
+      "defaults": {},
+      "funcname": "_SetTextureID",
+      "location": "imgui:3310",
+      "ov_cimguiname": "ImDrawList__SetTextureID",
+      "ret": "void",
+      "signature": "(ImTextureID)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList__TryMergeDrawCmds": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImDrawList__TryMergeDrawCmds",
+      "defaults": {},
+      "funcname": "_TryMergeDrawCmds",
+      "location": "imgui:3306",
+      "ov_cimguiname": "ImDrawList__TryMergeDrawCmds",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImDrawList_destroy": [
+    {
+      "args": "(ImDrawList* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImDrawList*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImDrawList_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3191",
+      "ov_cimguiname": "ImDrawList_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImDrawList*)",
+      "stname": "ImDrawList"
+    }
+  ],
+  "ImFontAtlasCustomRect_ImFontAtlasCustomRect": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlasCustomRect_ImFontAtlasCustomRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImFontAtlasCustomRect",
+      "location": "imgui:3411",
+      "ov_cimguiname": "ImFontAtlasCustomRect_ImFontAtlasCustomRect",
+      "signature": "()",
+      "stname": "ImFontAtlasCustomRect"
+    }
+  ],
+  "ImFontAtlasCustomRect_IsPacked": [
+    {
+      "args": "(ImFontAtlasCustomRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlasCustomRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlasCustomRect_IsPacked",
+      "defaults": {},
+      "funcname": "IsPacked",
+      "location": "imgui:3412",
+      "ov_cimguiname": "ImFontAtlasCustomRect_IsPacked",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImFontAtlasCustomRect"
+    }
+  ],
+  "ImFontAtlasCustomRect_destroy": [
+    {
+      "args": "(ImFontAtlasCustomRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlasCustomRect*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImFontAtlasCustomRect_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3411",
+      "ov_cimguiname": "ImFontAtlasCustomRect_destroy",
+      "ret": "void",
+      "signature": "(ImFontAtlasCustomRect*)",
+      "stname": "ImFontAtlasCustomRect"
+    }
+  ],
+  "ImFontAtlas_AddCustomRectFontGlyph": [
+    {
+      "args": "(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "font",
+          "type": "ImFont*"
+        },
+        {
+          "name": "id",
+          "type": "ImWchar"
+        },
+        {
+          "name": "width",
+          "type": "int"
+        },
+        {
+          "name": "height",
+          "type": "int"
+        },
+        {
+          "name": "advance_x",
+          "type": "float"
+        },
+        {
+          "name": "offset",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2& offset=ImVec2(0,0))",
+      "call_args": "(font,id,width,height,advance_x,offset)",
+      "cimguiname": "ImFontAtlas_AddCustomRectFontGlyph",
+      "defaults": {
+        "offset": "ImVec2(0,0)"
+      },
+      "funcname": "AddCustomRectFontGlyph",
+      "location": "imgui:3497",
+      "ov_cimguiname": "ImFontAtlas_AddCustomRectFontGlyph",
+      "ret": "int",
+      "signature": "(ImFont*,ImWchar,int,int,float,const ImVec2)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddCustomRectRegular": [
+    {
+      "args": "(ImFontAtlas* self,int width,int height)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "width",
+          "type": "int"
+        },
+        {
+          "name": "height",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int width,int height)",
+      "call_args": "(width,height)",
+      "cimguiname": "ImFontAtlas_AddCustomRectRegular",
+      "defaults": {},
+      "funcname": "AddCustomRectRegular",
+      "location": "imgui:3496",
+      "ov_cimguiname": "ImFontAtlas_AddCustomRectRegular",
+      "ret": "int",
+      "signature": "(int,int)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddFont": [
+    {
+      "args": "(ImFontAtlas* self,const ImFontConfig* font_cfg)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "font_cfg",
+          "type": "const ImFontConfig*"
+        }
+      ],
+      "argsoriginal": "(const ImFontConfig* font_cfg)",
+      "call_args": "(font_cfg)",
+      "cimguiname": "ImFontAtlas_AddFont",
+      "defaults": {},
+      "funcname": "AddFont",
+      "location": "imgui:3445",
+      "ov_cimguiname": "ImFontAtlas_AddFont",
+      "ret": "ImFont*",
+      "signature": "(const ImFontConfig*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddFontDefault": [
+    {
+      "args": "(ImFontAtlas* self,const ImFontConfig* font_cfg)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "font_cfg",
+          "type": "const ImFontConfig*"
+        }
+      ],
+      "argsoriginal": "(const ImFontConfig* font_cfg=((void*)0))",
+      "call_args": "(font_cfg)",
+      "cimguiname": "ImFontAtlas_AddFontDefault",
+      "defaults": {
+        "font_cfg": "NULL"
+      },
+      "funcname": "AddFontDefault",
+      "location": "imgui:3446",
+      "ov_cimguiname": "ImFontAtlas_AddFontDefault",
+      "ret": "ImFont*",
+      "signature": "(const ImFontConfig*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddFontFromFileTTF": [
+    {
+      "args": "(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "filename",
+          "type": "const char*"
+        },
+        {
+          "name": "size_pixels",
+          "type": "float"
+        },
+        {
+          "name": "font_cfg",
+          "type": "const ImFontConfig*"
+        },
+        {
+          "name": "glyph_ranges",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(const char* filename,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
+      "call_args": "(filename,size_pixels,font_cfg,glyph_ranges)",
+      "cimguiname": "ImFontAtlas_AddFontFromFileTTF",
+      "defaults": {
+        "font_cfg": "NULL",
+        "glyph_ranges": "NULL"
+      },
+      "funcname": "AddFontFromFileTTF",
+      "location": "imgui:3447",
+      "ov_cimguiname": "ImFontAtlas_AddFontFromFileTTF",
+      "ret": "ImFont*",
+      "signature": "(const char*,float,const ImFontConfig*,const ImWchar*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddFontFromMemoryCompressedBase85TTF": [
+    {
+      "args": "(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "compressed_font_data_base85",
+          "type": "const char*"
+        },
+        {
+          "name": "size_pixels",
+          "type": "float"
+        },
+        {
+          "name": "font_cfg",
+          "type": "const ImFontConfig*"
+        },
+        {
+          "name": "glyph_ranges",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
+      "call_args": "(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges)",
+      "cimguiname": "ImFontAtlas_AddFontFromMemoryCompressedBase85TTF",
+      "defaults": {
+        "font_cfg": "NULL",
+        "glyph_ranges": "NULL"
+      },
+      "funcname": "AddFontFromMemoryCompressedBase85TTF",
+      "location": "imgui:3450",
+      "ov_cimguiname": "ImFontAtlas_AddFontFromMemoryCompressedBase85TTF",
+      "ret": "ImFont*",
+      "signature": "(const char*,float,const ImFontConfig*,const ImWchar*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddFontFromMemoryCompressedTTF": [
+    {
+      "args": "(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_data_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "compressed_font_data",
+          "type": "const void*"
+        },
+        {
+          "name": "compressed_font_data_size",
+          "type": "int"
+        },
+        {
+          "name": "size_pixels",
+          "type": "float"
+        },
+        {
+          "name": "font_cfg",
+          "type": "const ImFontConfig*"
+        },
+        {
+          "name": "glyph_ranges",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(const void* compressed_font_data,int compressed_font_data_size,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
+      "call_args": "(compressed_font_data,compressed_font_data_size,size_pixels,font_cfg,glyph_ranges)",
+      "cimguiname": "ImFontAtlas_AddFontFromMemoryCompressedTTF",
+      "defaults": {
+        "font_cfg": "NULL",
+        "glyph_ranges": "NULL"
+      },
+      "funcname": "AddFontFromMemoryCompressedTTF",
+      "location": "imgui:3449",
+      "ov_cimguiname": "ImFontAtlas_AddFontFromMemoryCompressedTTF",
+      "ret": "ImFont*",
+      "signature": "(const void*,int,float,const ImFontConfig*,const ImWchar*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_AddFontFromMemoryTTF": [
+    {
+      "args": "(ImFontAtlas* self,void* font_data,int font_data_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "font_data",
+          "type": "void*"
+        },
+        {
+          "name": "font_data_size",
+          "type": "int"
+        },
+        {
+          "name": "size_pixels",
+          "type": "float"
+        },
+        {
+          "name": "font_cfg",
+          "type": "const ImFontConfig*"
+        },
+        {
+          "name": "glyph_ranges",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(void* font_data,int font_data_size,float size_pixels,const ImFontConfig* font_cfg=((void*)0),const ImWchar* glyph_ranges=((void*)0))",
+      "call_args": "(font_data,font_data_size,size_pixels,font_cfg,glyph_ranges)",
+      "cimguiname": "ImFontAtlas_AddFontFromMemoryTTF",
+      "defaults": {
+        "font_cfg": "NULL",
+        "glyph_ranges": "NULL"
+      },
+      "funcname": "AddFontFromMemoryTTF",
+      "location": "imgui:3448",
+      "ov_cimguiname": "ImFontAtlas_AddFontFromMemoryTTF",
+      "ret": "ImFont*",
+      "signature": "(void*,int,float,const ImFontConfig*,const ImWchar*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_Build": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_Build",
+      "defaults": {},
+      "funcname": "Build",
+      "location": "imgui:3461",
+      "ov_cimguiname": "ImFontAtlas_Build",
+      "ret": "bool",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_CalcCustomRectUV": [
+    {
+      "args": "(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "rect",
+          "type": "const ImFontAtlasCustomRect*"
+        },
+        {
+          "name": "out_uv_min",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "out_uv_max",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "(const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max)",
+      "call_args": "(rect,out_uv_min,out_uv_max)",
+      "cimguiname": "ImFontAtlas_CalcCustomRectUV",
+      "defaults": {},
+      "funcname": "CalcCustomRectUV",
+      "location": "imgui:3501",
+      "ov_cimguiname": "ImFontAtlas_CalcCustomRectUV",
+      "ret": "void",
+      "signature": "(const ImFontAtlasCustomRect*,ImVec2*,ImVec2*)const",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_Clear": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:3454",
+      "ov_cimguiname": "ImFontAtlas_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_ClearFonts": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_ClearFonts",
+      "defaults": {},
+      "funcname": "ClearFonts",
+      "location": "imgui:3453",
+      "ov_cimguiname": "ImFontAtlas_ClearFonts",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_ClearInputData": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_ClearInputData",
+      "defaults": {},
+      "funcname": "ClearInputData",
+      "location": "imgui:3451",
+      "ov_cimguiname": "ImFontAtlas_ClearInputData",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_ClearTexData": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_ClearTexData",
+      "defaults": {},
+      "funcname": "ClearTexData",
+      "location": "imgui:3452",
+      "ov_cimguiname": "ImFontAtlas_ClearTexData",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetCustomRectByIndex": [
+    {
+      "args": "(ImFontAtlas* self,int index)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int index)",
+      "call_args": "(index)",
+      "cimguiname": "ImFontAtlas_GetCustomRectByIndex",
+      "defaults": {},
+      "funcname": "GetCustomRectByIndex",
+      "location": "imgui:3498",
+      "ov_cimguiname": "ImFontAtlas_GetCustomRectByIndex",
+      "ret": "ImFontAtlasCustomRect*",
+      "signature": "(int)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesChineseFull": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesChineseFull",
+      "defaults": {},
+      "funcname": "GetGlyphRangesChineseFull",
+      "location": "imgui:3479",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesChineseFull",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon",
+      "defaults": {},
+      "funcname": "GetGlyphRangesChineseSimplifiedCommon",
+      "location": "imgui:3480",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesCyrillic": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesCyrillic",
+      "defaults": {},
+      "funcname": "GetGlyphRangesCyrillic",
+      "location": "imgui:3481",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesCyrillic",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesDefault": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesDefault",
+      "defaults": {},
+      "funcname": "GetGlyphRangesDefault",
+      "location": "imgui:3475",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesDefault",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesGreek": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesGreek",
+      "defaults": {},
+      "funcname": "GetGlyphRangesGreek",
+      "location": "imgui:3476",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesGreek",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesJapanese": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesJapanese",
+      "defaults": {},
+      "funcname": "GetGlyphRangesJapanese",
+      "location": "imgui:3478",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesJapanese",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesKorean": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesKorean",
+      "defaults": {},
+      "funcname": "GetGlyphRangesKorean",
+      "location": "imgui:3477",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesKorean",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesThai": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesThai",
+      "defaults": {},
+      "funcname": "GetGlyphRangesThai",
+      "location": "imgui:3482",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesThai",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetGlyphRangesVietnamese": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_GetGlyphRangesVietnamese",
+      "defaults": {},
+      "funcname": "GetGlyphRangesVietnamese",
+      "location": "imgui:3483",
+      "ov_cimguiname": "ImFontAtlas_GetGlyphRangesVietnamese",
+      "ret": "const ImWchar*",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetMouseCursorTexData": [
+    {
+      "args": "(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "cursor",
+          "type": "ImGuiMouseCursor"
+        },
+        {
+          "name": "out_offset",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "out_size",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "out_uv_border",
+          "type": "ImVec2[2]"
+        },
+        {
+          "name": "out_uv_fill",
+          "type": "ImVec2[2]"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2])",
+      "call_args": "(cursor,out_offset,out_size,out_uv_border,out_uv_fill)",
+      "cimguiname": "ImFontAtlas_GetMouseCursorTexData",
+      "defaults": {},
+      "funcname": "GetMouseCursorTexData",
+      "location": "imgui:3502",
+      "ov_cimguiname": "ImFontAtlas_GetMouseCursorTexData",
+      "ret": "bool",
+      "signature": "(ImGuiMouseCursor,ImVec2*,ImVec2*,ImVec2[2],ImVec2[2])",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetTexDataAsAlpha8": [
+    {
+      "args": "(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "out_pixels",
+          "type": "unsigned char**"
+        },
+        {
+          "name": "out_width",
+          "type": "int*"
+        },
+        {
+          "name": "out_height",
+          "type": "int*"
+        },
+        {
+          "name": "out_bytes_per_pixel",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel=((void*)0))",
+      "call_args": "(out_pixels,out_width,out_height,out_bytes_per_pixel)",
+      "cimguiname": "ImFontAtlas_GetTexDataAsAlpha8",
+      "defaults": {
+        "out_bytes_per_pixel": "NULL"
+      },
+      "funcname": "GetTexDataAsAlpha8",
+      "location": "imgui:3462",
+      "ov_cimguiname": "ImFontAtlas_GetTexDataAsAlpha8",
+      "ret": "void",
+      "signature": "(unsigned char**,int*,int*,int*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_GetTexDataAsRGBA32": [
+    {
+      "args": "(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "out_pixels",
+          "type": "unsigned char**"
+        },
+        {
+          "name": "out_width",
+          "type": "int*"
+        },
+        {
+          "name": "out_height",
+          "type": "int*"
+        },
+        {
+          "name": "out_bytes_per_pixel",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel=((void*)0))",
+      "call_args": "(out_pixels,out_width,out_height,out_bytes_per_pixel)",
+      "cimguiname": "ImFontAtlas_GetTexDataAsRGBA32",
+      "defaults": {
+        "out_bytes_per_pixel": "NULL"
+      },
+      "funcname": "GetTexDataAsRGBA32",
+      "location": "imgui:3463",
+      "ov_cimguiname": "ImFontAtlas_GetTexDataAsRGBA32",
+      "ret": "void",
+      "signature": "(unsigned char**,int*,int*,int*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_ImFontAtlas": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_ImFontAtlas",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImFontAtlas",
+      "location": "imgui:3443",
+      "ov_cimguiname": "ImFontAtlas_ImFontAtlas",
+      "signature": "()",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_IsBuilt": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontAtlas_IsBuilt",
+      "defaults": {},
+      "funcname": "IsBuilt",
+      "location": "imgui:3464",
+      "ov_cimguiname": "ImFontAtlas_IsBuilt",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_SetTexID": [
+    {
+      "args": "(ImFontAtlas* self,ImTextureID id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "id",
+          "type": "ImTextureID"
+        }
+      ],
+      "argsoriginal": "(ImTextureID id)",
+      "call_args": "(id)",
+      "cimguiname": "ImFontAtlas_SetTexID",
+      "defaults": {},
+      "funcname": "SetTexID",
+      "location": "imgui:3465",
+      "ov_cimguiname": "ImFontAtlas_SetTexID",
+      "ret": "void",
+      "signature": "(ImTextureID)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontAtlas_destroy": [
+    {
+      "args": "(ImFontAtlas* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImFontAtlas_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3444",
+      "ov_cimguiname": "ImFontAtlas_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImFontAtlas*)",
+      "stname": "ImFontAtlas"
+    }
+  ],
+  "ImFontConfig_ImFontConfig": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontConfig_ImFontConfig",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImFontConfig",
+      "location": "imgui:3368",
+      "ov_cimguiname": "ImFontConfig_ImFontConfig",
+      "signature": "()",
+      "stname": "ImFontConfig"
+    }
+  ],
+  "ImFontConfig_destroy": [
+    {
+      "args": "(ImFontConfig* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontConfig*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImFontConfig_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3368",
+      "ov_cimguiname": "ImFontConfig_destroy",
+      "ret": "void",
+      "signature": "(ImFontConfig*)",
+      "stname": "ImFontConfig"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_AddChar": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self,ImWchar c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        }
+      ],
+      "argsoriginal": "(ImWchar c)",
+      "call_args": "(c)",
+      "cimguiname": "ImFontGlyphRangesBuilder_AddChar",
+      "defaults": {},
+      "funcname": "AddChar",
+      "location": "imgui:3393",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_AddChar",
+      "ret": "void",
+      "signature": "(ImWchar)",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_AddRanges": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self,const ImWchar* ranges)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        },
+        {
+          "name": "ranges",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(const ImWchar* ranges)",
+      "call_args": "(ranges)",
+      "cimguiname": "ImFontGlyphRangesBuilder_AddRanges",
+      "defaults": {},
+      "funcname": "AddRanges",
+      "location": "imgui:3395",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_AddRanges",
+      "ret": "void",
+      "signature": "(const ImWchar*)",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_AddText": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
+      "call_args": "(text,text_end)",
+      "cimguiname": "ImFontGlyphRangesBuilder_AddText",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "AddText",
+      "location": "imgui:3394",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_AddText",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_BuildRanges": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        },
+        {
+          "name": "out_ranges",
+          "type": "ImVector_ImWchar*"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImWchar>* out_ranges)",
+      "call_args": "(out_ranges)",
+      "cimguiname": "ImFontGlyphRangesBuilder_BuildRanges",
+      "defaults": {},
+      "funcname": "BuildRanges",
+      "location": "imgui:3396",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_BuildRanges",
+      "ret": "void",
+      "signature": "(ImVector_ImWchar*)",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_Clear": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontGlyphRangesBuilder_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:3390",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_GetBit": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self,size_t n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        },
+        {
+          "name": "n",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(size_t n)",
+      "call_args": "(n)",
+      "cimguiname": "ImFontGlyphRangesBuilder_GetBit",
+      "defaults": {},
+      "funcname": "GetBit",
+      "location": "imgui:3391",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_GetBit",
+      "ret": "bool",
+      "signature": "(size_t)const",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImFontGlyphRangesBuilder",
+      "location": "imgui:3389",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder",
+      "signature": "()",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_SetBit": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self,size_t n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        },
+        {
+          "name": "n",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(size_t n)",
+      "call_args": "(n)",
+      "cimguiname": "ImFontGlyphRangesBuilder_SetBit",
+      "defaults": {},
+      "funcname": "SetBit",
+      "location": "imgui:3392",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_SetBit",
+      "ret": "void",
+      "signature": "(size_t)",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFontGlyphRangesBuilder_destroy": [
+    {
+      "args": "(ImFontGlyphRangesBuilder* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFontGlyphRangesBuilder*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImFontGlyphRangesBuilder_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3389",
+      "ov_cimguiname": "ImFontGlyphRangesBuilder_destroy",
+      "ret": "void",
+      "signature": "(ImFontGlyphRangesBuilder*)",
+      "stname": "ImFontGlyphRangesBuilder"
+    }
+  ],
+  "ImFont_AddGlyph": [
+    {
+      "args": "(ImFont* self,const ImFontConfig* src_cfg,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "src_cfg",
+          "type": "const ImFontConfig*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        },
+        {
+          "name": "x0",
+          "type": "float"
+        },
+        {
+          "name": "y0",
+          "type": "float"
+        },
+        {
+          "name": "x1",
+          "type": "float"
+        },
+        {
+          "name": "y1",
+          "type": "float"
+        },
+        {
+          "name": "u0",
+          "type": "float"
+        },
+        {
+          "name": "v0",
+          "type": "float"
+        },
+        {
+          "name": "u1",
+          "type": "float"
+        },
+        {
+          "name": "v1",
+          "type": "float"
+        },
+        {
+          "name": "advance_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImFontConfig* src_cfg,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x)",
+      "call_args": "(src_cfg,c,x0,y0,x1,y1,u0,v0,u1,v1,advance_x)",
+      "cimguiname": "ImFont_AddGlyph",
+      "defaults": {},
+      "funcname": "AddGlyph",
+      "location": "imgui:3593",
+      "ov_cimguiname": "ImFont_AddGlyph",
+      "ret": "void",
+      "signature": "(const ImFontConfig*,ImWchar,float,float,float,float,float,float,float,float,float)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_AddRemapChar": [
+    {
+      "args": "(ImFont* self,ImWchar dst,ImWchar src,bool overwrite_dst)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "dst",
+          "type": "ImWchar"
+        },
+        {
+          "name": "src",
+          "type": "ImWchar"
+        },
+        {
+          "name": "overwrite_dst",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImWchar dst,ImWchar src,bool overwrite_dst=true)",
+      "call_args": "(dst,src,overwrite_dst)",
+      "cimguiname": "ImFont_AddRemapChar",
+      "defaults": {
+        "overwrite_dst": "true"
+      },
+      "funcname": "AddRemapChar",
+      "location": "imgui:3594",
+      "ov_cimguiname": "ImFont_AddRemapChar",
+      "ret": "void",
+      "signature": "(ImWchar,ImWchar,bool)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_BuildLookupTable": [
+    {
+      "args": "(ImFont* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFont_BuildLookupTable",
+      "defaults": {},
+      "funcname": "BuildLookupTable",
+      "location": "imgui:3590",
+      "ov_cimguiname": "ImFont_BuildLookupTable",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_CalcTextSizeA": [
+    {
+      "args": "(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "max_width",
+          "type": "float"
+        },
+        {
+          "name": "wrap_width",
+          "type": "float"
+        },
+        {
+          "name": "text_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "remaining",
+          "type": "const char**"
+        }
+      ],
+      "argsoriginal": "(float size,float max_width,float wrap_width,const char* text_begin,const char* text_end=((void*)0),const char** remaining=((void*)0))",
+      "call_args": "(size,max_width,wrap_width,text_begin,text_end,remaining)",
+      "cimguiname": "ImFont_CalcTextSizeA",
+      "defaults": {
+        "remaining": "NULL",
+        "text_end": "NULL"
+      },
+      "funcname": "CalcTextSizeA",
+      "location": "imgui:3584",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImFont_CalcTextSizeA",
+      "ret": "void",
+      "signature": "(float,float,float,const char*,const char*,const char**)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_CalcWordWrapPositionA": [
+    {
+      "args": "(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "scale",
+          "type": "float"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "wrap_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float scale,const char* text,const char* text_end,float wrap_width)",
+      "call_args": "(scale,text,text_end,wrap_width)",
+      "cimguiname": "ImFont_CalcWordWrapPositionA",
+      "defaults": {},
+      "funcname": "CalcWordWrapPositionA",
+      "location": "imgui:3585",
+      "ov_cimguiname": "ImFont_CalcWordWrapPositionA",
+      "ret": "const char*",
+      "signature": "(float,const char*,const char*,float)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_ClearOutputData": [
+    {
+      "args": "(ImFont* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFont_ClearOutputData",
+      "defaults": {},
+      "funcname": "ClearOutputData",
+      "location": "imgui:3591",
+      "ov_cimguiname": "ImFont_ClearOutputData",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_FindGlyph": [
+    {
+      "args": "(ImFont* self,ImWchar c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        }
+      ],
+      "argsoriginal": "(ImWchar c)",
+      "call_args": "(c)",
+      "cimguiname": "ImFont_FindGlyph",
+      "defaults": {},
+      "funcname": "FindGlyph",
+      "location": "imgui:3576",
+      "ov_cimguiname": "ImFont_FindGlyph",
+      "ret": "const ImFontGlyph*",
+      "signature": "(ImWchar)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_FindGlyphNoFallback": [
+    {
+      "args": "(ImFont* self,ImWchar c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        }
+      ],
+      "argsoriginal": "(ImWchar c)",
+      "call_args": "(c)",
+      "cimguiname": "ImFont_FindGlyphNoFallback",
+      "defaults": {},
+      "funcname": "FindGlyphNoFallback",
+      "location": "imgui:3577",
+      "ov_cimguiname": "ImFont_FindGlyphNoFallback",
+      "ret": "const ImFontGlyph*",
+      "signature": "(ImWchar)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_GetCharAdvance": [
+    {
+      "args": "(ImFont* self,ImWchar c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        }
+      ],
+      "argsoriginal": "(ImWchar c)",
+      "call_args": "(c)",
+      "cimguiname": "ImFont_GetCharAdvance",
+      "defaults": {},
+      "funcname": "GetCharAdvance",
+      "location": "imgui:3578",
+      "ov_cimguiname": "ImFont_GetCharAdvance",
+      "ret": "float",
+      "signature": "(ImWchar)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_GetDebugName": [
+    {
+      "args": "(ImFont* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFont_GetDebugName",
+      "defaults": {},
+      "funcname": "GetDebugName",
+      "location": "imgui:3580",
+      "ov_cimguiname": "ImFont_GetDebugName",
+      "ret": "const char*",
+      "signature": "()const",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_GrowIndex": [
+    {
+      "args": "(ImFont* self,int new_size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "new_size",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int new_size)",
+      "call_args": "(new_size)",
+      "cimguiname": "ImFont_GrowIndex",
+      "defaults": {},
+      "funcname": "GrowIndex",
+      "location": "imgui:3592",
+      "ov_cimguiname": "ImFont_GrowIndex",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_ImFont": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFont_ImFont",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImFont",
+      "location": "imgui:3574",
+      "ov_cimguiname": "ImFont_ImFont",
+      "signature": "()",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_IsGlyphRangeUnused": [
+    {
+      "args": "(ImFont* self,unsigned int c_begin,unsigned int c_last)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "c_begin",
+          "type": "unsigned int"
+        },
+        {
+          "name": "c_last",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(unsigned int c_begin,unsigned int c_last)",
+      "call_args": "(c_begin,c_last)",
+      "cimguiname": "ImFont_IsGlyphRangeUnused",
+      "defaults": {},
+      "funcname": "IsGlyphRangeUnused",
+      "location": "imgui:3596",
+      "ov_cimguiname": "ImFont_IsGlyphRangeUnused",
+      "ret": "bool",
+      "signature": "(unsigned int,unsigned int)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_IsLoaded": [
+    {
+      "args": "(ImFont* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImFont_IsLoaded",
+      "defaults": {},
+      "funcname": "IsLoaded",
+      "location": "imgui:3579",
+      "ov_cimguiname": "ImFont_IsLoaded",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_RenderChar": [
+    {
+      "args": "(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,ImWchar c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,float size,const ImVec2& pos,ImU32 col,ImWchar c)",
+      "call_args": "(draw_list,size,pos,col,c)",
+      "cimguiname": "ImFont_RenderChar",
+      "defaults": {},
+      "funcname": "RenderChar",
+      "location": "imgui:3586",
+      "ov_cimguiname": "ImFont_RenderChar",
+      "ret": "void",
+      "signature": "(ImDrawList*,float,const ImVec2,ImU32,ImWchar)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_RenderText": [
+    {
+      "args": "(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,bool cpu_fine_clip)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "clip_rect",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "text_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "wrap_width",
+          "type": "float"
+        },
+        {
+          "name": "cpu_fine_clip",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,float size,const ImVec2& pos,ImU32 col,const ImVec4& clip_rect,const char* text_begin,const char* text_end,float wrap_width=0.0f,bool cpu_fine_clip=false)",
+      "call_args": "(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip)",
+      "cimguiname": "ImFont_RenderText",
+      "defaults": {
+        "cpu_fine_clip": "false",
+        "wrap_width": "0.0f"
+      },
+      "funcname": "RenderText",
+      "location": "imgui:3587",
+      "ov_cimguiname": "ImFont_RenderText",
+      "ret": "void",
+      "signature": "(ImDrawList*,float,const ImVec2,ImU32,const ImVec4,const char*,const char*,float,bool)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_SetGlyphVisible": [
+    {
+      "args": "(ImFont* self,ImWchar c,bool visible)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar"
+        },
+        {
+          "name": "visible",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImWchar c,bool visible)",
+      "call_args": "(c,visible)",
+      "cimguiname": "ImFont_SetGlyphVisible",
+      "defaults": {},
+      "funcname": "SetGlyphVisible",
+      "location": "imgui:3595",
+      "ov_cimguiname": "ImFont_SetGlyphVisible",
+      "ret": "void",
+      "signature": "(ImWchar,bool)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImFont_destroy": [
+    {
+      "args": "(ImFont* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImFont*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImFont_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3575",
+      "ov_cimguiname": "ImFont_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImFont*)",
+      "stname": "ImFont"
+    }
+  ],
+  "ImGuiBoxSelectState_ImGuiBoxSelectState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiBoxSelectState_ImGuiBoxSelectState",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiBoxSelectState",
+      "location": "imgui_internal:1772",
+      "ov_cimguiname": "ImGuiBoxSelectState_ImGuiBoxSelectState",
+      "signature": "()",
+      "stname": "ImGuiBoxSelectState"
+    }
+  ],
+  "ImGuiBoxSelectState_destroy": [
+    {
+      "args": "(ImGuiBoxSelectState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiBoxSelectState*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiBoxSelectState_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1772",
+      "ov_cimguiname": "ImGuiBoxSelectState_destroy",
+      "ret": "void",
+      "signature": "(ImGuiBoxSelectState*)",
+      "stname": "ImGuiBoxSelectState"
+    }
+  ],
+  "ImGuiComboPreviewData_ImGuiComboPreviewData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiComboPreviewData_ImGuiComboPreviewData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiComboPreviewData",
+      "location": "imgui_internal:1069",
+      "ov_cimguiname": "ImGuiComboPreviewData_ImGuiComboPreviewData",
+      "signature": "()",
+      "stname": "ImGuiComboPreviewData"
+    }
+  ],
+  "ImGuiComboPreviewData_destroy": [
+    {
+      "args": "(ImGuiComboPreviewData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiComboPreviewData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiComboPreviewData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1069",
+      "ov_cimguiname": "ImGuiComboPreviewData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiComboPreviewData*)",
+      "stname": "ImGuiComboPreviewData"
+    }
+  ],
+  "ImGuiContextHook_ImGuiContextHook": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiContextHook_ImGuiContextHook",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiContextHook",
+      "location": "imgui_internal:2215",
+      "ov_cimguiname": "ImGuiContextHook_ImGuiContextHook",
+      "signature": "()",
+      "stname": "ImGuiContextHook"
+    }
+  ],
+  "ImGuiContextHook_destroy": [
+    {
+      "args": "(ImGuiContextHook* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiContextHook*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiContextHook_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2215",
+      "ov_cimguiname": "ImGuiContextHook_destroy",
+      "ret": "void",
+      "signature": "(ImGuiContextHook*)",
+      "stname": "ImGuiContextHook"
+    }
+  ],
+  "ImGuiContext_ImGuiContext": [
+    {
+      "args": "(ImFontAtlas* shared_font_atlas)",
+      "argsT": [
+        {
+          "name": "shared_font_atlas",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* shared_font_atlas)",
+      "call_args": "(shared_font_atlas)",
+      "cimguiname": "ImGuiContext_ImGuiContext",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiContext",
+      "location": "imgui_internal:2603",
+      "ov_cimguiname": "ImGuiContext_ImGuiContext",
+      "signature": "(ImFontAtlas*)",
+      "stname": "ImGuiContext"
+    }
+  ],
+  "ImGuiContext_destroy": [
+    {
+      "args": "(ImGuiContext* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiContext_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2603",
+      "ov_cimguiname": "ImGuiContext_destroy",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": "ImGuiContext"
+    }
+  ],
+  "ImGuiDataVarInfo_GetVarPtr": [
+    {
+      "args": "(ImGuiDataVarInfo* self,void* parent)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDataVarInfo*"
+        },
+        {
+          "name": "parent",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void* parent)",
+      "call_args": "(parent)",
+      "cimguiname": "ImGuiDataVarInfo_GetVarPtr",
+      "defaults": {},
+      "funcname": "GetVarPtr",
+      "location": "imgui_internal:820",
+      "ov_cimguiname": "ImGuiDataVarInfo_GetVarPtr",
+      "ret": "void*",
+      "signature": "(void*)const",
+      "stname": "ImGuiDataVarInfo"
+    }
+  ],
+  "ImGuiDebugAllocInfo_ImGuiDebugAllocInfo": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDebugAllocInfo_ImGuiDebugAllocInfo",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiDebugAllocInfo",
+      "location": "imgui_internal:2155",
+      "ov_cimguiname": "ImGuiDebugAllocInfo_ImGuiDebugAllocInfo",
+      "signature": "()",
+      "stname": "ImGuiDebugAllocInfo"
+    }
+  ],
+  "ImGuiDebugAllocInfo_destroy": [
+    {
+      "args": "(ImGuiDebugAllocInfo* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDebugAllocInfo*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiDebugAllocInfo_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2155",
+      "ov_cimguiname": "ImGuiDebugAllocInfo_destroy",
+      "ret": "void",
+      "signature": "(ImGuiDebugAllocInfo*)",
+      "stname": "ImGuiDebugAllocInfo"
+    }
+  ],
+  "ImGuiDockContext_ImGuiDockContext": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockContext_ImGuiDockContext",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiDockContext",
+      "location": "imgui_internal:1972",
+      "ov_cimguiname": "ImGuiDockContext_ImGuiDockContext",
+      "signature": "()",
+      "stname": "ImGuiDockContext"
+    }
+  ],
+  "ImGuiDockContext_destroy": [
+    {
+      "args": "(ImGuiDockContext* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockContext*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiDockContext_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1972",
+      "ov_cimguiname": "ImGuiDockContext_destroy",
+      "ret": "void",
+      "signature": "(ImGuiDockContext*)",
+      "stname": "ImGuiDockContext"
+    }
+  ],
+  "ImGuiDockNode_ImGuiDockNode": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "ImGuiDockNode_ImGuiDockNode",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiDockNode",
+      "location": "imgui_internal:1926",
+      "ov_cimguiname": "ImGuiDockNode_ImGuiDockNode",
+      "signature": "(ImGuiID)",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsCentralNode": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsCentralNode",
+      "defaults": {},
+      "funcname": "IsCentralNode",
+      "location": "imgui_internal:1931",
+      "ov_cimguiname": "ImGuiDockNode_IsCentralNode",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsDockSpace": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsDockSpace",
+      "defaults": {},
+      "funcname": "IsDockSpace",
+      "location": "imgui_internal:1929",
+      "ov_cimguiname": "ImGuiDockNode_IsDockSpace",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsEmpty": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsEmpty",
+      "defaults": {},
+      "funcname": "IsEmpty",
+      "location": "imgui_internal:1936",
+      "ov_cimguiname": "ImGuiDockNode_IsEmpty",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsFloatingNode": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsFloatingNode",
+      "defaults": {},
+      "funcname": "IsFloatingNode",
+      "location": "imgui_internal:1930",
+      "ov_cimguiname": "ImGuiDockNode_IsFloatingNode",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsHiddenTabBar": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsHiddenTabBar",
+      "defaults": {},
+      "funcname": "IsHiddenTabBar",
+      "location": "imgui_internal:1932",
+      "ov_cimguiname": "ImGuiDockNode_IsHiddenTabBar",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsLeafNode": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsLeafNode",
+      "defaults": {},
+      "funcname": "IsLeafNode",
+      "location": "imgui_internal:1935",
+      "ov_cimguiname": "ImGuiDockNode_IsLeafNode",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsNoTabBar": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsNoTabBar",
+      "defaults": {},
+      "funcname": "IsNoTabBar",
+      "location": "imgui_internal:1933",
+      "ov_cimguiname": "ImGuiDockNode_IsNoTabBar",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsRootNode": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsRootNode",
+      "defaults": {},
+      "funcname": "IsRootNode",
+      "location": "imgui_internal:1928",
+      "ov_cimguiname": "ImGuiDockNode_IsRootNode",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_IsSplitNode": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_IsSplitNode",
+      "defaults": {},
+      "funcname": "IsSplitNode",
+      "location": "imgui_internal:1934",
+      "ov_cimguiname": "ImGuiDockNode_IsSplitNode",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_Rect": [
+    {
+      "args": "(ImRect *pOut,ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_Rect",
+      "defaults": {},
+      "funcname": "Rect",
+      "location": "imgui_internal:1937",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiDockNode_Rect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_SetLocalFlags": [
+    {
+      "args": "(ImGuiDockNode* self,ImGuiDockNodeFlags flags)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDockNodeFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiDockNodeFlags flags)",
+      "call_args": "(flags)",
+      "cimguiname": "ImGuiDockNode_SetLocalFlags",
+      "defaults": {},
+      "funcname": "SetLocalFlags",
+      "location": "imgui_internal:1939",
+      "ov_cimguiname": "ImGuiDockNode_SetLocalFlags",
+      "ret": "void",
+      "signature": "(ImGuiDockNodeFlags)",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_UpdateMergedFlags": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiDockNode_UpdateMergedFlags",
+      "defaults": {},
+      "funcname": "UpdateMergedFlags",
+      "location": "imgui_internal:1940",
+      "ov_cimguiname": "ImGuiDockNode_UpdateMergedFlags",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiDockNode_destroy": [
+    {
+      "args": "(ImGuiDockNode* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiDockNode_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1927",
+      "ov_cimguiname": "ImGuiDockNode_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiDockNode*)",
+      "stname": "ImGuiDockNode"
+    }
+  ],
+  "ImGuiErrorRecoveryState_ImGuiErrorRecoveryState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiErrorRecoveryState_ImGuiErrorRecoveryState",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiErrorRecoveryState",
+      "location": "imgui_internal:1307",
+      "ov_cimguiname": "ImGuiErrorRecoveryState_ImGuiErrorRecoveryState",
+      "signature": "()",
+      "stname": "ImGuiErrorRecoveryState"
+    }
+  ],
+  "ImGuiErrorRecoveryState_destroy": [
+    {
+      "args": "(ImGuiErrorRecoveryState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiErrorRecoveryState*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiErrorRecoveryState_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1307",
+      "ov_cimguiname": "ImGuiErrorRecoveryState_destroy",
+      "ret": "void",
+      "signature": "(ImGuiErrorRecoveryState*)",
+      "stname": "ImGuiErrorRecoveryState"
+    }
+  ],
+  "ImGuiFreeType_GetBuilderForFreeType": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiFreeType_GetBuilderForFreeType",
+      "defaults": {},
+      "funcname": "GetBuilderForFreeType",
+      "location": "imgui_freetype:46",
+      "namespace": "ImGuiFreeType",
+      "ov_cimguiname": "ImGuiFreeType_GetBuilderForFreeType",
+      "ret": "const ImFontBuilderIO*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGuiFreeType_SetAllocatorFunctions": [
+    {
+      "args": "(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data)",
+      "argsT": [
+        {
+          "name": "alloc_func",
+          "ret": "void*",
+          "signature": "(size_t sz,void* user_data)",
+          "type": "void*(*)(size_t sz,void* user_data)"
+        },
+        {
+          "name": "free_func",
+          "ret": "void",
+          "signature": "(void* ptr,void* user_data)",
+          "type": "void(*)(void* ptr,void* user_data)"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data=nullptr)",
+      "call_args": "(alloc_func,free_func,user_data)",
+      "cimguiname": "ImGuiFreeType_SetAllocatorFunctions",
+      "defaults": {
+        "user_data": "nullptr"
+      },
+      "funcname": "SetAllocatorFunctions",
+      "location": "imgui_freetype:50",
+      "namespace": "ImGuiFreeType",
+      "ov_cimguiname": "ImGuiFreeType_SetAllocatorFunctions",
+      "ret": "void",
+      "signature": "(void*(*)(size_t,void*),void(*)(void*,void*),void*)",
+      "stname": ""
+    }
+  ],
+  "ImGuiIDStackTool_ImGuiIDStackTool": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiIDStackTool_ImGuiIDStackTool",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiIDStackTool",
+      "location": "imgui_internal:2197",
+      "ov_cimguiname": "ImGuiIDStackTool_ImGuiIDStackTool",
+      "signature": "()",
+      "stname": "ImGuiIDStackTool"
+    }
+  ],
+  "ImGuiIDStackTool_destroy": [
+    {
+      "args": "(ImGuiIDStackTool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIDStackTool*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiIDStackTool_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2197",
+      "ov_cimguiname": "ImGuiIDStackTool_destroy",
+      "ret": "void",
+      "signature": "(ImGuiIDStackTool*)",
+      "stname": "ImGuiIDStackTool"
+    }
+  ],
+  "ImGuiIO_AddFocusEvent": [
+    {
+      "args": "(ImGuiIO* self,bool focused)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "focused",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool focused)",
+      "call_args": "(focused)",
+      "cimguiname": "ImGuiIO_AddFocusEvent",
+      "defaults": {},
+      "funcname": "AddFocusEvent",
+      "location": "imgui:2426",
+      "ov_cimguiname": "ImGuiIO_AddFocusEvent",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddInputCharacter": [
+    {
+      "args": "(ImGuiIO* self,unsigned int c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "c",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(unsigned int c)",
+      "call_args": "(c)",
+      "cimguiname": "ImGuiIO_AddInputCharacter",
+      "defaults": {},
+      "funcname": "AddInputCharacter",
+      "location": "imgui:2427",
+      "ov_cimguiname": "ImGuiIO_AddInputCharacter",
+      "ret": "void",
+      "signature": "(unsigned int)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddInputCharacterUTF16": [
+    {
+      "args": "(ImGuiIO* self,ImWchar16 c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "c",
+          "type": "ImWchar16"
+        }
+      ],
+      "argsoriginal": "(ImWchar16 c)",
+      "call_args": "(c)",
+      "cimguiname": "ImGuiIO_AddInputCharacterUTF16",
+      "defaults": {},
+      "funcname": "AddInputCharacterUTF16",
+      "location": "imgui:2428",
+      "ov_cimguiname": "ImGuiIO_AddInputCharacterUTF16",
+      "ret": "void",
+      "signature": "(ImWchar16)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddInputCharactersUTF8": [
+    {
+      "args": "(ImGuiIO* self,const char* str)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "str",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str)",
+      "call_args": "(str)",
+      "cimguiname": "ImGuiIO_AddInputCharactersUTF8",
+      "defaults": {},
+      "funcname": "AddInputCharactersUTF8",
+      "location": "imgui:2429",
+      "ov_cimguiname": "ImGuiIO_AddInputCharactersUTF8",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddKeyAnalogEvent": [
+    {
+      "args": "(ImGuiIO* self,ImGuiKey key,bool down,float v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "down",
+          "type": "bool"
+        },
+        {
+          "name": "v",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,bool down,float v)",
+      "call_args": "(key,down,v)",
+      "cimguiname": "ImGuiIO_AddKeyAnalogEvent",
+      "defaults": {},
+      "funcname": "AddKeyAnalogEvent",
+      "location": "imgui:2420",
+      "ov_cimguiname": "ImGuiIO_AddKeyAnalogEvent",
+      "ret": "void",
+      "signature": "(ImGuiKey,bool,float)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddKeyEvent": [
+    {
+      "args": "(ImGuiIO* self,ImGuiKey key,bool down)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "down",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,bool down)",
+      "call_args": "(key,down)",
+      "cimguiname": "ImGuiIO_AddKeyEvent",
+      "defaults": {},
+      "funcname": "AddKeyEvent",
+      "location": "imgui:2419",
+      "ov_cimguiname": "ImGuiIO_AddKeyEvent",
+      "ret": "void",
+      "signature": "(ImGuiKey,bool)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddMouseButtonEvent": [
+    {
+      "args": "(ImGuiIO* self,int button,bool down)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "button",
+          "type": "int"
+        },
+        {
+          "name": "down",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(int button,bool down)",
+      "call_args": "(button,down)",
+      "cimguiname": "ImGuiIO_AddMouseButtonEvent",
+      "defaults": {},
+      "funcname": "AddMouseButtonEvent",
+      "location": "imgui:2422",
+      "ov_cimguiname": "ImGuiIO_AddMouseButtonEvent",
+      "ret": "void",
+      "signature": "(int,bool)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddMousePosEvent": [
+    {
+      "args": "(ImGuiIO* self,float x,float y)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "x",
+          "type": "float"
+        },
+        {
+          "name": "y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x,float y)",
+      "call_args": "(x,y)",
+      "cimguiname": "ImGuiIO_AddMousePosEvent",
+      "defaults": {},
+      "funcname": "AddMousePosEvent",
+      "location": "imgui:2421",
+      "ov_cimguiname": "ImGuiIO_AddMousePosEvent",
+      "ret": "void",
+      "signature": "(float,float)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddMouseSourceEvent": [
+    {
+      "args": "(ImGuiIO* self,ImGuiMouseSource source)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "source",
+          "type": "ImGuiMouseSource"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseSource source)",
+      "call_args": "(source)",
+      "cimguiname": "ImGuiIO_AddMouseSourceEvent",
+      "defaults": {},
+      "funcname": "AddMouseSourceEvent",
+      "location": "imgui:2424",
+      "ov_cimguiname": "ImGuiIO_AddMouseSourceEvent",
+      "ret": "void",
+      "signature": "(ImGuiMouseSource)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddMouseViewportEvent": [
+    {
+      "args": "(ImGuiIO* self,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "ImGuiIO_AddMouseViewportEvent",
+      "defaults": {},
+      "funcname": "AddMouseViewportEvent",
+      "location": "imgui:2425",
+      "ov_cimguiname": "ImGuiIO_AddMouseViewportEvent",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_AddMouseWheelEvent": [
+    {
+      "args": "(ImGuiIO* self,float wheel_x,float wheel_y)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "wheel_x",
+          "type": "float"
+        },
+        {
+          "name": "wheel_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float wheel_x,float wheel_y)",
+      "call_args": "(wheel_x,wheel_y)",
+      "cimguiname": "ImGuiIO_AddMouseWheelEvent",
+      "defaults": {},
+      "funcname": "AddMouseWheelEvent",
+      "location": "imgui:2423",
+      "ov_cimguiname": "ImGuiIO_AddMouseWheelEvent",
+      "ret": "void",
+      "signature": "(float,float)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_ClearEventsQueue": [
+    {
+      "args": "(ImGuiIO* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiIO_ClearEventsQueue",
+      "defaults": {},
+      "funcname": "ClearEventsQueue",
+      "location": "imgui:2433",
+      "ov_cimguiname": "ImGuiIO_ClearEventsQueue",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_ClearInputKeys": [
+    {
+      "args": "(ImGuiIO* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiIO_ClearInputKeys",
+      "defaults": {},
+      "funcname": "ClearInputKeys",
+      "location": "imgui:2434",
+      "ov_cimguiname": "ImGuiIO_ClearInputKeys",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_ClearInputMouse": [
+    {
+      "args": "(ImGuiIO* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiIO_ClearInputMouse",
+      "defaults": {},
+      "funcname": "ClearInputMouse",
+      "location": "imgui:2435",
+      "ov_cimguiname": "ImGuiIO_ClearInputMouse",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_ImGuiIO": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiIO_ImGuiIO",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiIO",
+      "location": "imgui:2524",
+      "ov_cimguiname": "ImGuiIO_ImGuiIO",
+      "signature": "()",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_SetAppAcceptingEvents": [
+    {
+      "args": "(ImGuiIO* self,bool accepting_events)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "accepting_events",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool accepting_events)",
+      "call_args": "(accepting_events)",
+      "cimguiname": "ImGuiIO_SetAppAcceptingEvents",
+      "defaults": {},
+      "funcname": "SetAppAcceptingEvents",
+      "location": "imgui:2432",
+      "ov_cimguiname": "ImGuiIO_SetAppAcceptingEvents",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_SetKeyEventNativeData": [
+    {
+      "args": "(ImGuiIO* self,ImGuiKey key,int native_keycode,int native_scancode,int native_legacy_index)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "native_keycode",
+          "type": "int"
+        },
+        {
+          "name": "native_scancode",
+          "type": "int"
+        },
+        {
+          "name": "native_legacy_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,int native_keycode,int native_scancode,int native_legacy_index=-1)",
+      "call_args": "(key,native_keycode,native_scancode,native_legacy_index)",
+      "cimguiname": "ImGuiIO_SetKeyEventNativeData",
+      "defaults": {
+        "native_legacy_index": "-1"
+      },
+      "funcname": "SetKeyEventNativeData",
+      "location": "imgui:2431",
+      "ov_cimguiname": "ImGuiIO_SetKeyEventNativeData",
+      "ret": "void",
+      "signature": "(ImGuiKey,int,int,int)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiIO_destroy": [
+    {
+      "args": "(ImGuiIO* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiIO*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiIO_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2524",
+      "ov_cimguiname": "ImGuiIO_destroy",
+      "ret": "void",
+      "signature": "(ImGuiIO*)",
+      "stname": "ImGuiIO"
+    }
+  ],
+  "ImGuiInputEvent_ImGuiInputEvent": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputEvent_ImGuiInputEvent",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiInputEvent",
+      "location": "imgui_internal:1439",
+      "ov_cimguiname": "ImGuiInputEvent_ImGuiInputEvent",
+      "signature": "()",
+      "stname": "ImGuiInputEvent"
+    }
+  ],
+  "ImGuiInputEvent_destroy": [
+    {
+      "args": "(ImGuiInputEvent* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputEvent*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiInputEvent_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1439",
+      "ov_cimguiname": "ImGuiInputEvent_destroy",
+      "ret": "void",
+      "signature": "(ImGuiInputEvent*)",
+      "stname": "ImGuiInputEvent"
+    }
+  ],
+  "ImGuiInputTextCallbackData_ClearSelection": [
+    {
+      "args": "(ImGuiInputTextCallbackData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextCallbackData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextCallbackData_ClearSelection",
+      "defaults": {},
+      "funcname": "ClearSelection",
+      "location": "imgui:2568",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_ClearSelection",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextCallbackData_DeleteChars": [
+    {
+      "args": "(ImGuiInputTextCallbackData* self,int pos,int bytes_count)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextCallbackData*"
+        },
+        {
+          "name": "pos",
+          "type": "int"
+        },
+        {
+          "name": "bytes_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int pos,int bytes_count)",
+      "call_args": "(pos,bytes_count)",
+      "cimguiname": "ImGuiInputTextCallbackData_DeleteChars",
+      "defaults": {},
+      "funcname": "DeleteChars",
+      "location": "imgui:2565",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_DeleteChars",
+      "ret": "void",
+      "signature": "(int,int)",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextCallbackData_HasSelection": [
+    {
+      "args": "(ImGuiInputTextCallbackData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextCallbackData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextCallbackData_HasSelection",
+      "defaults": {},
+      "funcname": "HasSelection",
+      "location": "imgui:2569",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_HasSelection",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiInputTextCallbackData",
+      "location": "imgui:2564",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_ImGuiInputTextCallbackData",
+      "signature": "()",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextCallbackData_InsertChars": [
+    {
+      "args": "(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextCallbackData*"
+        },
+        {
+          "name": "pos",
+          "type": "int"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(int pos,const char* text,const char* text_end=((void*)0))",
+      "call_args": "(pos,text,text_end)",
+      "cimguiname": "ImGuiInputTextCallbackData_InsertChars",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "InsertChars",
+      "location": "imgui:2566",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_InsertChars",
+      "ret": "void",
+      "signature": "(int,const char*,const char*)",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextCallbackData_SelectAll": [
+    {
+      "args": "(ImGuiInputTextCallbackData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextCallbackData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextCallbackData_SelectAll",
+      "defaults": {},
+      "funcname": "SelectAll",
+      "location": "imgui:2567",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_SelectAll",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextCallbackData_destroy": [
+    {
+      "args": "(ImGuiInputTextCallbackData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextCallbackData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiInputTextCallbackData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2564",
+      "ov_cimguiname": "ImGuiInputTextCallbackData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiInputTextCallbackData*)",
+      "stname": "ImGuiInputTextCallbackData"
+    }
+  ],
+  "ImGuiInputTextDeactivatedState_ClearFreeMemory": [
+    {
+      "args": "(ImGuiInputTextDeactivatedState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextDeactivatedState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextDeactivatedState_ClearFreeMemory",
+      "defaults": {},
+      "funcname": "ClearFreeMemory",
+      "location": "imgui_internal:1115",
+      "ov_cimguiname": "ImGuiInputTextDeactivatedState_ClearFreeMemory",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextDeactivatedState"
+    }
+  ],
+  "ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiInputTextDeactivatedState",
+      "location": "imgui_internal:1114",
+      "ov_cimguiname": "ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState",
+      "signature": "()",
+      "stname": "ImGuiInputTextDeactivatedState"
+    }
+  ],
+  "ImGuiInputTextDeactivatedState_destroy": [
+    {
+      "args": "(ImGuiInputTextDeactivatedState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextDeactivatedState*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiInputTextDeactivatedState_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1114",
+      "ov_cimguiname": "ImGuiInputTextDeactivatedState_destroy",
+      "ret": "void",
+      "signature": "(ImGuiInputTextDeactivatedState*)",
+      "stname": "ImGuiInputTextDeactivatedState"
+    }
+  ],
+  "ImGuiInputTextState_ClearFreeMemory": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ClearFreeMemory",
+      "defaults": {},
+      "funcname": "ClearFreeMemory",
+      "location": "imgui_internal:1154",
+      "ov_cimguiname": "ImGuiInputTextState_ClearFreeMemory",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_ClearSelection": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ClearSelection",
+      "defaults": {},
+      "funcname": "ClearSelection",
+      "location": "imgui_internal:1162",
+      "ov_cimguiname": "ImGuiInputTextState_ClearSelection",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_ClearText": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ClearText",
+      "defaults": {},
+      "funcname": "ClearText",
+      "location": "imgui_internal:1153",
+      "ov_cimguiname": "ImGuiInputTextState_ClearText",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_CursorAnimReset": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_CursorAnimReset",
+      "defaults": {},
+      "funcname": "CursorAnimReset",
+      "location": "imgui_internal:1159",
+      "ov_cimguiname": "ImGuiInputTextState_CursorAnimReset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_CursorClamp": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_CursorClamp",
+      "defaults": {},
+      "funcname": "CursorClamp",
+      "location": "imgui_internal:1160",
+      "ov_cimguiname": "ImGuiInputTextState_CursorClamp",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_GetCursorPos": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_GetCursorPos",
+      "defaults": {},
+      "funcname": "GetCursorPos",
+      "location": "imgui_internal:1163",
+      "ov_cimguiname": "ImGuiInputTextState_GetCursorPos",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_GetSelectionEnd": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_GetSelectionEnd",
+      "defaults": {},
+      "funcname": "GetSelectionEnd",
+      "location": "imgui_internal:1165",
+      "ov_cimguiname": "ImGuiInputTextState_GetSelectionEnd",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_GetSelectionStart": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_GetSelectionStart",
+      "defaults": {},
+      "funcname": "GetSelectionStart",
+      "location": "imgui_internal:1164",
+      "ov_cimguiname": "ImGuiInputTextState_GetSelectionStart",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_HasSelection": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_HasSelection",
+      "defaults": {},
+      "funcname": "HasSelection",
+      "location": "imgui_internal:1161",
+      "ov_cimguiname": "ImGuiInputTextState_HasSelection",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_ImGuiInputTextState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ImGuiInputTextState",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiInputTextState",
+      "location": "imgui_internal:1151",
+      "ov_cimguiname": "ImGuiInputTextState_ImGuiInputTextState",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_OnCharPressed": [
+    {
+      "args": "(ImGuiInputTextState* self,unsigned int c)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        },
+        {
+          "name": "c",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(unsigned int c)",
+      "call_args": "(c)",
+      "cimguiname": "ImGuiInputTextState_OnCharPressed",
+      "defaults": {},
+      "funcname": "OnCharPressed",
+      "location": "imgui_internal:1156",
+      "ov_cimguiname": "ImGuiInputTextState_OnCharPressed",
+      "ret": "void",
+      "signature": "(unsigned int)",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_OnKeyPressed": [
+    {
+      "args": "(ImGuiInputTextState* self,int key)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        },
+        {
+          "name": "key",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int key)",
+      "call_args": "(key)",
+      "cimguiname": "ImGuiInputTextState_OnKeyPressed",
+      "defaults": {},
+      "funcname": "OnKeyPressed",
+      "location": "imgui_internal:1155",
+      "ov_cimguiname": "ImGuiInputTextState_OnKeyPressed",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_ReloadUserBufAndKeepSelection": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ReloadUserBufAndKeepSelection",
+      "defaults": {},
+      "funcname": "ReloadUserBufAndKeepSelection",
+      "location": "imgui_internal:1174",
+      "ov_cimguiname": "ImGuiInputTextState_ReloadUserBufAndKeepSelection",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_ReloadUserBufAndMoveToEnd": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ReloadUserBufAndMoveToEnd",
+      "defaults": {},
+      "funcname": "ReloadUserBufAndMoveToEnd",
+      "location": "imgui_internal:1175",
+      "ov_cimguiname": "ImGuiInputTextState_ReloadUserBufAndMoveToEnd",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_ReloadUserBufAndSelectAll": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_ReloadUserBufAndSelectAll",
+      "defaults": {},
+      "funcname": "ReloadUserBufAndSelectAll",
+      "location": "imgui_internal:1173",
+      "ov_cimguiname": "ImGuiInputTextState_ReloadUserBufAndSelectAll",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_SelectAll": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiInputTextState_SelectAll",
+      "defaults": {},
+      "funcname": "SelectAll",
+      "location": "imgui_internal:1166",
+      "ov_cimguiname": "ImGuiInputTextState_SelectAll",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiInputTextState_destroy": [
+    {
+      "args": "(ImGuiInputTextState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiInputTextState_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1152",
+      "ov_cimguiname": "ImGuiInputTextState_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiInputTextState*)",
+      "stname": "ImGuiInputTextState"
+    }
+  ],
+  "ImGuiKeyOwnerData_ImGuiKeyOwnerData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiKeyOwnerData_ImGuiKeyOwnerData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiKeyOwnerData",
+      "location": "imgui_internal:1483",
+      "ov_cimguiname": "ImGuiKeyOwnerData_ImGuiKeyOwnerData",
+      "signature": "()",
+      "stname": "ImGuiKeyOwnerData"
+    }
+  ],
+  "ImGuiKeyOwnerData_destroy": [
+    {
+      "args": "(ImGuiKeyOwnerData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiKeyOwnerData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiKeyOwnerData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1483",
+      "ov_cimguiname": "ImGuiKeyOwnerData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiKeyOwnerData*)",
+      "stname": "ImGuiKeyOwnerData"
+    }
+  ],
+  "ImGuiKeyRoutingData_ImGuiKeyRoutingData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiKeyRoutingData_ImGuiKeyRoutingData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiKeyRoutingData",
+      "location": "imgui_internal:1459",
+      "ov_cimguiname": "ImGuiKeyRoutingData_ImGuiKeyRoutingData",
+      "signature": "()",
+      "stname": "ImGuiKeyRoutingData"
+    }
+  ],
+  "ImGuiKeyRoutingData_destroy": [
+    {
+      "args": "(ImGuiKeyRoutingData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiKeyRoutingData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiKeyRoutingData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1459",
+      "ov_cimguiname": "ImGuiKeyRoutingData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiKeyRoutingData*)",
+      "stname": "ImGuiKeyRoutingData"
+    }
+  ],
+  "ImGuiKeyRoutingTable_Clear": [
+    {
+      "args": "(ImGuiKeyRoutingTable* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiKeyRoutingTable*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiKeyRoutingTable_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui_internal:1471",
+      "ov_cimguiname": "ImGuiKeyRoutingTable_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiKeyRoutingTable"
+    }
+  ],
+  "ImGuiKeyRoutingTable_ImGuiKeyRoutingTable": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiKeyRoutingTable_ImGuiKeyRoutingTable",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiKeyRoutingTable",
+      "location": "imgui_internal:1470",
+      "ov_cimguiname": "ImGuiKeyRoutingTable_ImGuiKeyRoutingTable",
+      "signature": "()",
+      "stname": "ImGuiKeyRoutingTable"
+    }
+  ],
+  "ImGuiKeyRoutingTable_destroy": [
+    {
+      "args": "(ImGuiKeyRoutingTable* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiKeyRoutingTable*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiKeyRoutingTable_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1470",
+      "ov_cimguiname": "ImGuiKeyRoutingTable_destroy",
+      "ret": "void",
+      "signature": "(ImGuiKeyRoutingTable*)",
+      "stname": "ImGuiKeyRoutingTable"
+    }
+  ],
+  "ImGuiLastItemData_ImGuiLastItemData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiLastItemData_ImGuiLastItemData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiLastItemData",
+      "location": "imgui_internal:1277",
+      "ov_cimguiname": "ImGuiLastItemData_ImGuiLastItemData",
+      "signature": "()",
+      "stname": "ImGuiLastItemData"
+    }
+  ],
+  "ImGuiLastItemData_destroy": [
+    {
+      "args": "(ImGuiLastItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiLastItemData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiLastItemData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1277",
+      "ov_cimguiname": "ImGuiLastItemData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiLastItemData*)",
+      "stname": "ImGuiLastItemData"
+    }
+  ],
+  "ImGuiListClipperData_ImGuiListClipperData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiListClipperData_ImGuiListClipperData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiListClipperData",
+      "location": "imgui_internal:1554",
+      "ov_cimguiname": "ImGuiListClipperData_ImGuiListClipperData",
+      "signature": "()",
+      "stname": "ImGuiListClipperData"
+    }
+  ],
+  "ImGuiListClipperData_Reset": [
+    {
+      "args": "(ImGuiListClipperData* self,ImGuiListClipper* clipper)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipperData*"
+        },
+        {
+          "name": "clipper",
+          "type": "ImGuiListClipper*"
+        }
+      ],
+      "argsoriginal": "(ImGuiListClipper* clipper)",
+      "call_args": "(clipper)",
+      "cimguiname": "ImGuiListClipperData_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "imgui_internal:1555",
+      "ov_cimguiname": "ImGuiListClipperData_Reset",
+      "ret": "void",
+      "signature": "(ImGuiListClipper*)",
+      "stname": "ImGuiListClipperData"
+    }
+  ],
+  "ImGuiListClipperData_destroy": [
+    {
+      "args": "(ImGuiListClipperData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipperData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiListClipperData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1554",
+      "ov_cimguiname": "ImGuiListClipperData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiListClipperData*)",
+      "stname": "ImGuiListClipperData"
+    }
+  ],
+  "ImGuiListClipperRange_FromIndices": [
+    {
+      "args": "(int min,int max)",
+      "argsT": [
+        {
+          "name": "min",
+          "type": "int"
+        },
+        {
+          "name": "max",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int min,int max)",
+      "call_args": "(min,max)",
+      "cimguiname": "ImGuiListClipperRange_FromIndices",
+      "defaults": {},
+      "funcname": "FromIndices",
+      "is_static_function": true,
+      "location": "imgui_internal:1541",
+      "ov_cimguiname": "ImGuiListClipperRange_FromIndices",
+      "ret": "ImGuiListClipperRange",
+      "signature": "(int,int)",
+      "stname": "ImGuiListClipperRange"
+    }
+  ],
+  "ImGuiListClipperRange_FromPositions": [
+    {
+      "args": "(float y1,float y2,int off_min,int off_max)",
+      "argsT": [
+        {
+          "name": "y1",
+          "type": "float"
+        },
+        {
+          "name": "y2",
+          "type": "float"
+        },
+        {
+          "name": "off_min",
+          "type": "int"
+        },
+        {
+          "name": "off_max",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(float y1,float y2,int off_min,int off_max)",
+      "call_args": "(y1,y2,off_min,off_max)",
+      "cimguiname": "ImGuiListClipperRange_FromPositions",
+      "defaults": {},
+      "funcname": "FromPositions",
+      "is_static_function": true,
+      "location": "imgui_internal:1542",
+      "ov_cimguiname": "ImGuiListClipperRange_FromPositions",
+      "ret": "ImGuiListClipperRange",
+      "signature": "(float,float,int,int)",
+      "stname": "ImGuiListClipperRange"
+    }
+  ],
+  "ImGuiListClipper_Begin": [
+    {
+      "args": "(ImGuiListClipper* self,int items_count,float items_height)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "items_height",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(int items_count,float items_height=-1.0f)",
+      "call_args": "(items_count,items_height)",
+      "cimguiname": "ImGuiListClipper_Begin",
+      "defaults": {
+        "items_height": "-1.0f"
+      },
+      "funcname": "Begin",
+      "location": "imgui:2784",
+      "ov_cimguiname": "ImGuiListClipper_Begin",
+      "ret": "void",
+      "signature": "(int,float)",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_End": [
+    {
+      "args": "(ImGuiListClipper* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiListClipper_End",
+      "defaults": {},
+      "funcname": "End",
+      "location": "imgui:2785",
+      "ov_cimguiname": "ImGuiListClipper_End",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_ImGuiListClipper": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiListClipper_ImGuiListClipper",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiListClipper",
+      "location": "imgui:2782",
+      "ov_cimguiname": "ImGuiListClipper_ImGuiListClipper",
+      "signature": "()",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_IncludeItemByIndex": [
+    {
+      "args": "(ImGuiListClipper* self,int item_index)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        },
+        {
+          "name": "item_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int item_index)",
+      "call_args": "(item_index)",
+      "cimguiname": "ImGuiListClipper_IncludeItemByIndex",
+      "defaults": {},
+      "funcname": "IncludeItemByIndex",
+      "location": "imgui:2790",
+      "ov_cimguiname": "ImGuiListClipper_IncludeItemByIndex",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_IncludeItemsByIndex": [
+    {
+      "args": "(ImGuiListClipper* self,int item_begin,int item_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        },
+        {
+          "name": "item_begin",
+          "type": "int"
+        },
+        {
+          "name": "item_end",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int item_begin,int item_end)",
+      "call_args": "(item_begin,item_end)",
+      "cimguiname": "ImGuiListClipper_IncludeItemsByIndex",
+      "defaults": {},
+      "funcname": "IncludeItemsByIndex",
+      "location": "imgui:2791",
+      "ov_cimguiname": "ImGuiListClipper_IncludeItemsByIndex",
+      "ret": "void",
+      "signature": "(int,int)",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_SeekCursorForItem": [
+    {
+      "args": "(ImGuiListClipper* self,int item_index)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        },
+        {
+          "name": "item_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int item_index)",
+      "call_args": "(item_index)",
+      "cimguiname": "ImGuiListClipper_SeekCursorForItem",
+      "defaults": {},
+      "funcname": "SeekCursorForItem",
+      "location": "imgui:2796",
+      "ov_cimguiname": "ImGuiListClipper_SeekCursorForItem",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_Step": [
+    {
+      "args": "(ImGuiListClipper* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiListClipper_Step",
+      "defaults": {},
+      "funcname": "Step",
+      "location": "imgui:2786",
+      "ov_cimguiname": "ImGuiListClipper_Step",
+      "ret": "bool",
+      "signature": "()",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiListClipper_destroy": [
+    {
+      "args": "(ImGuiListClipper* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiListClipper*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiListClipper_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2783",
+      "ov_cimguiname": "ImGuiListClipper_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiListClipper*)",
+      "stname": "ImGuiListClipper"
+    }
+  ],
+  "ImGuiMenuColumns_CalcNextTotalWidth": [
+    {
+      "args": "(ImGuiMenuColumns* self,bool update_offsets)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMenuColumns*"
+        },
+        {
+          "name": "update_offsets",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool update_offsets)",
+      "call_args": "(update_offsets)",
+      "cimguiname": "ImGuiMenuColumns_CalcNextTotalWidth",
+      "defaults": {},
+      "funcname": "CalcNextTotalWidth",
+      "location": "imgui_internal:1105",
+      "ov_cimguiname": "ImGuiMenuColumns_CalcNextTotalWidth",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": "ImGuiMenuColumns"
+    }
+  ],
+  "ImGuiMenuColumns_DeclColumns": [
+    {
+      "args": "(ImGuiMenuColumns* self,float w_icon,float w_label,float w_shortcut,float w_mark)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMenuColumns*"
+        },
+        {
+          "name": "w_icon",
+          "type": "float"
+        },
+        {
+          "name": "w_label",
+          "type": "float"
+        },
+        {
+          "name": "w_shortcut",
+          "type": "float"
+        },
+        {
+          "name": "w_mark",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float w_icon,float w_label,float w_shortcut,float w_mark)",
+      "call_args": "(w_icon,w_label,w_shortcut,w_mark)",
+      "cimguiname": "ImGuiMenuColumns_DeclColumns",
+      "defaults": {},
+      "funcname": "DeclColumns",
+      "location": "imgui_internal:1104",
+      "ov_cimguiname": "ImGuiMenuColumns_DeclColumns",
+      "ret": "float",
+      "signature": "(float,float,float,float)",
+      "stname": "ImGuiMenuColumns"
+    }
+  ],
+  "ImGuiMenuColumns_ImGuiMenuColumns": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiMenuColumns_ImGuiMenuColumns",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiMenuColumns",
+      "location": "imgui_internal:1102",
+      "ov_cimguiname": "ImGuiMenuColumns_ImGuiMenuColumns",
+      "signature": "()",
+      "stname": "ImGuiMenuColumns"
+    }
+  ],
+  "ImGuiMenuColumns_Update": [
+    {
+      "args": "(ImGuiMenuColumns* self,float spacing,bool window_reappearing)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMenuColumns*"
+        },
+        {
+          "name": "spacing",
+          "type": "float"
+        },
+        {
+          "name": "window_reappearing",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(float spacing,bool window_reappearing)",
+      "call_args": "(spacing,window_reappearing)",
+      "cimguiname": "ImGuiMenuColumns_Update",
+      "defaults": {},
+      "funcname": "Update",
+      "location": "imgui_internal:1103",
+      "ov_cimguiname": "ImGuiMenuColumns_Update",
+      "ret": "void",
+      "signature": "(float,bool)",
+      "stname": "ImGuiMenuColumns"
+    }
+  ],
+  "ImGuiMenuColumns_destroy": [
+    {
+      "args": "(ImGuiMenuColumns* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMenuColumns*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiMenuColumns_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1102",
+      "ov_cimguiname": "ImGuiMenuColumns_destroy",
+      "ret": "void",
+      "signature": "(ImGuiMenuColumns*)",
+      "stname": "ImGuiMenuColumns"
+    }
+  ],
+  "ImGuiMultiSelectState_ImGuiMultiSelectState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiMultiSelectState_ImGuiMultiSelectState",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiMultiSelectState",
+      "location": "imgui_internal:1819",
+      "ov_cimguiname": "ImGuiMultiSelectState_ImGuiMultiSelectState",
+      "signature": "()",
+      "stname": "ImGuiMultiSelectState"
+    }
+  ],
+  "ImGuiMultiSelectState_destroy": [
+    {
+      "args": "(ImGuiMultiSelectState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMultiSelectState*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiMultiSelectState_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1819",
+      "ov_cimguiname": "ImGuiMultiSelectState_destroy",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectState*)",
+      "stname": "ImGuiMultiSelectState"
+    }
+  ],
+  "ImGuiMultiSelectTempData_Clear": [
+    {
+      "args": "(ImGuiMultiSelectTempData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMultiSelectTempData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiMultiSelectTempData_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui_internal:1803",
+      "ov_cimguiname": "ImGuiMultiSelectTempData_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiMultiSelectTempData"
+    }
+  ],
+  "ImGuiMultiSelectTempData_ClearIO": [
+    {
+      "args": "(ImGuiMultiSelectTempData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMultiSelectTempData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiMultiSelectTempData_ClearIO",
+      "defaults": {},
+      "funcname": "ClearIO",
+      "location": "imgui_internal:1804",
+      "ov_cimguiname": "ImGuiMultiSelectTempData_ClearIO",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiMultiSelectTempData"
+    }
+  ],
+  "ImGuiMultiSelectTempData_ImGuiMultiSelectTempData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiMultiSelectTempData_ImGuiMultiSelectTempData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiMultiSelectTempData",
+      "location": "imgui_internal:1802",
+      "ov_cimguiname": "ImGuiMultiSelectTempData_ImGuiMultiSelectTempData",
+      "signature": "()",
+      "stname": "ImGuiMultiSelectTempData"
+    }
+  ],
+  "ImGuiMultiSelectTempData_destroy": [
+    {
+      "args": "(ImGuiMultiSelectTempData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiMultiSelectTempData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiMultiSelectTempData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1802",
+      "ov_cimguiname": "ImGuiMultiSelectTempData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectTempData*)",
+      "stname": "ImGuiMultiSelectTempData"
+    }
+  ],
+  "ImGuiNavItemData_Clear": [
+    {
+      "args": "(ImGuiNavItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiNavItemData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiNavItemData_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui_internal:1644",
+      "ov_cimguiname": "ImGuiNavItemData_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiNavItemData"
+    }
+  ],
+  "ImGuiNavItemData_ImGuiNavItemData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiNavItemData_ImGuiNavItemData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiNavItemData",
+      "location": "imgui_internal:1643",
+      "ov_cimguiname": "ImGuiNavItemData_ImGuiNavItemData",
+      "signature": "()",
+      "stname": "ImGuiNavItemData"
+    }
+  ],
+  "ImGuiNavItemData_destroy": [
+    {
+      "args": "(ImGuiNavItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiNavItemData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiNavItemData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1643",
+      "ov_cimguiname": "ImGuiNavItemData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiNavItemData*)",
+      "stname": "ImGuiNavItemData"
+    }
+  ],
+  "ImGuiNextItemData_ClearFlags": [
+    {
+      "args": "(ImGuiNextItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiNextItemData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiNextItemData_ClearFlags",
+      "defaults": {},
+      "funcname": "ClearFlags",
+      "location": "imgui_internal:1261",
+      "ov_cimguiname": "ImGuiNextItemData_ClearFlags",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiNextItemData"
+    }
+  ],
+  "ImGuiNextItemData_ImGuiNextItemData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiNextItemData_ImGuiNextItemData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiNextItemData",
+      "location": "imgui_internal:1260",
+      "ov_cimguiname": "ImGuiNextItemData_ImGuiNextItemData",
+      "signature": "()",
+      "stname": "ImGuiNextItemData"
+    }
+  ],
+  "ImGuiNextItemData_destroy": [
+    {
+      "args": "(ImGuiNextItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiNextItemData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiNextItemData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1260",
+      "ov_cimguiname": "ImGuiNextItemData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiNextItemData*)",
+      "stname": "ImGuiNextItemData"
+    }
+  ],
+  "ImGuiNextWindowData_ClearFlags": [
+    {
+      "args": "(ImGuiNextWindowData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiNextWindowData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiNextWindowData_ClearFlags",
+      "defaults": {},
+      "funcname": "ClearFlags",
+      "location": "imgui_internal:1232",
+      "ov_cimguiname": "ImGuiNextWindowData_ClearFlags",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiNextWindowData"
+    }
+  ],
+  "ImGuiNextWindowData_ImGuiNextWindowData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiNextWindowData_ImGuiNextWindowData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiNextWindowData",
+      "location": "imgui_internal:1231",
+      "ov_cimguiname": "ImGuiNextWindowData_ImGuiNextWindowData",
+      "signature": "()",
+      "stname": "ImGuiNextWindowData"
+    }
+  ],
+  "ImGuiNextWindowData_destroy": [
+    {
+      "args": "(ImGuiNextWindowData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiNextWindowData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiNextWindowData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1231",
+      "ov_cimguiname": "ImGuiNextWindowData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiNextWindowData*)",
+      "stname": "ImGuiNextWindowData"
+    }
+  ],
+  "ImGuiOldColumnData_ImGuiOldColumnData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiOldColumnData_ImGuiOldColumnData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiOldColumnData",
+      "location": "imgui_internal:1723",
+      "ov_cimguiname": "ImGuiOldColumnData_ImGuiOldColumnData",
+      "signature": "()",
+      "stname": "ImGuiOldColumnData"
+    }
+  ],
+  "ImGuiOldColumnData_destroy": [
+    {
+      "args": "(ImGuiOldColumnData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiOldColumnData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiOldColumnData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1723",
+      "ov_cimguiname": "ImGuiOldColumnData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiOldColumnData*)",
+      "stname": "ImGuiOldColumnData"
+    }
+  ],
+  "ImGuiOldColumns_ImGuiOldColumns": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiOldColumns_ImGuiOldColumns",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiOldColumns",
+      "location": "imgui_internal:1744",
+      "ov_cimguiname": "ImGuiOldColumns_ImGuiOldColumns",
+      "signature": "()",
+      "stname": "ImGuiOldColumns"
+    }
+  ],
+  "ImGuiOldColumns_destroy": [
+    {
+      "args": "(ImGuiOldColumns* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiOldColumns*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiOldColumns_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1744",
+      "ov_cimguiname": "ImGuiOldColumns_destroy",
+      "ret": "void",
+      "signature": "(ImGuiOldColumns*)",
+      "stname": "ImGuiOldColumns"
+    }
+  ],
+  "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiOnceUponAFrame",
+      "location": "imgui:2642",
+      "ov_cimguiname": "ImGuiOnceUponAFrame_ImGuiOnceUponAFrame",
+      "signature": "()",
+      "stname": "ImGuiOnceUponAFrame"
+    }
+  ],
+  "ImGuiOnceUponAFrame_destroy": [
+    {
+      "args": "(ImGuiOnceUponAFrame* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiOnceUponAFrame*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiOnceUponAFrame_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2642",
+      "ov_cimguiname": "ImGuiOnceUponAFrame_destroy",
+      "ret": "void",
+      "signature": "(ImGuiOnceUponAFrame*)",
+      "stname": "ImGuiOnceUponAFrame"
+    }
+  ],
+  "ImGuiPayload_Clear": [
+    {
+      "args": "(ImGuiPayload* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPayload*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPayload_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:2620",
+      "ov_cimguiname": "ImGuiPayload_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiPayload"
+    }
+  ],
+  "ImGuiPayload_ImGuiPayload": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPayload_ImGuiPayload",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPayload",
+      "location": "imgui:2619",
+      "ov_cimguiname": "ImGuiPayload_ImGuiPayload",
+      "signature": "()",
+      "stname": "ImGuiPayload"
+    }
+  ],
+  "ImGuiPayload_IsDataType": [
+    {
+      "args": "(ImGuiPayload* self,const char* type)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPayload*"
+        },
+        {
+          "name": "type",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* type)",
+      "call_args": "(type)",
+      "cimguiname": "ImGuiPayload_IsDataType",
+      "defaults": {},
+      "funcname": "IsDataType",
+      "location": "imgui:2621",
+      "ov_cimguiname": "ImGuiPayload_IsDataType",
+      "ret": "bool",
+      "signature": "(const char*)const",
+      "stname": "ImGuiPayload"
+    }
+  ],
+  "ImGuiPayload_IsDelivery": [
+    {
+      "args": "(ImGuiPayload* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPayload*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPayload_IsDelivery",
+      "defaults": {},
+      "funcname": "IsDelivery",
+      "location": "imgui:2623",
+      "ov_cimguiname": "ImGuiPayload_IsDelivery",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiPayload"
+    }
+  ],
+  "ImGuiPayload_IsPreview": [
+    {
+      "args": "(ImGuiPayload* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPayload*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPayload_IsPreview",
+      "defaults": {},
+      "funcname": "IsPreview",
+      "location": "imgui:2622",
+      "ov_cimguiname": "ImGuiPayload_IsPreview",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiPayload"
+    }
+  ],
+  "ImGuiPayload_destroy": [
+    {
+      "args": "(ImGuiPayload* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPayload*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiPayload_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2619",
+      "ov_cimguiname": "ImGuiPayload_destroy",
+      "ret": "void",
+      "signature": "(ImGuiPayload*)",
+      "stname": "ImGuiPayload"
+    }
+  ],
+  "ImGuiPlatformIO_ImGuiPlatformIO": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPlatformIO_ImGuiPlatformIO",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPlatformIO",
+      "location": "imgui:3719",
+      "ov_cimguiname": "ImGuiPlatformIO_ImGuiPlatformIO",
+      "signature": "()",
+      "stname": "ImGuiPlatformIO"
+    }
+  ],
+  "ImGuiPlatformIO_destroy": [
+    {
+      "args": "(ImGuiPlatformIO* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPlatformIO*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiPlatformIO_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3719",
+      "ov_cimguiname": "ImGuiPlatformIO_destroy",
+      "ret": "void",
+      "signature": "(ImGuiPlatformIO*)",
+      "stname": "ImGuiPlatformIO"
+    }
+  ],
+  "ImGuiPlatformImeData_ImGuiPlatformImeData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPlatformImeData_ImGuiPlatformImeData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPlatformImeData",
+      "location": "imgui:3829",
+      "ov_cimguiname": "ImGuiPlatformImeData_ImGuiPlatformImeData",
+      "signature": "()",
+      "stname": "ImGuiPlatformImeData"
+    }
+  ],
+  "ImGuiPlatformImeData_destroy": [
+    {
+      "args": "(ImGuiPlatformImeData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPlatformImeData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiPlatformImeData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3829",
+      "ov_cimguiname": "ImGuiPlatformImeData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiPlatformImeData*)",
+      "stname": "ImGuiPlatformImeData"
+    }
+  ],
+  "ImGuiPlatformMonitor_ImGuiPlatformMonitor": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPlatformMonitor_ImGuiPlatformMonitor",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPlatformMonitor",
+      "location": "imgui:3819",
+      "ov_cimguiname": "ImGuiPlatformMonitor_ImGuiPlatformMonitor",
+      "signature": "()",
+      "stname": "ImGuiPlatformMonitor"
+    }
+  ],
+  "ImGuiPlatformMonitor_destroy": [
+    {
+      "args": "(ImGuiPlatformMonitor* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPlatformMonitor*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiPlatformMonitor_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3819",
+      "ov_cimguiname": "ImGuiPlatformMonitor_destroy",
+      "ret": "void",
+      "signature": "(ImGuiPlatformMonitor*)",
+      "stname": "ImGuiPlatformMonitor"
+    }
+  ],
+  "ImGuiPopupData_ImGuiPopupData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiPopupData_ImGuiPopupData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPopupData",
+      "location": "imgui_internal:1358",
+      "ov_cimguiname": "ImGuiPopupData_ImGuiPopupData",
+      "signature": "()",
+      "stname": "ImGuiPopupData"
+    }
+  ],
+  "ImGuiPopupData_destroy": [
+    {
+      "args": "(ImGuiPopupData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPopupData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiPopupData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1358",
+      "ov_cimguiname": "ImGuiPopupData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiPopupData*)",
+      "stname": "ImGuiPopupData"
+    }
+  ],
+  "ImGuiPtrOrIndex_ImGuiPtrOrIndex": [
+    {
+      "args": "(void* ptr)",
+      "argsT": [
+        {
+          "name": "ptr",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void* ptr)",
+      "call_args": "(ptr)",
+      "cimguiname": "ImGuiPtrOrIndex_ImGuiPtrOrIndex",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPtrOrIndex",
+      "location": "imgui_internal:1331",
+      "ov_cimguiname": "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr",
+      "signature": "(void*)",
+      "stname": "ImGuiPtrOrIndex"
+    },
+    {
+      "args": "(int index)",
+      "argsT": [
+        {
+          "name": "index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int index)",
+      "call_args": "(index)",
+      "cimguiname": "ImGuiPtrOrIndex_ImGuiPtrOrIndex",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiPtrOrIndex",
+      "location": "imgui_internal:1332",
+      "ov_cimguiname": "ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int",
+      "signature": "(int)",
+      "stname": "ImGuiPtrOrIndex"
+    }
+  ],
+  "ImGuiPtrOrIndex_destroy": [
+    {
+      "args": "(ImGuiPtrOrIndex* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiPtrOrIndex*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiPtrOrIndex_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1331",
+      "ov_cimguiname": "ImGuiPtrOrIndex_destroy",
+      "ret": "void",
+      "signature": "(ImGuiPtrOrIndex*)",
+      "stname": "ImGuiPtrOrIndex"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_ApplyRequests": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self,ImGuiMultiSelectIO* ms_io)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        },
+        {
+          "name": "ms_io",
+          "type": "ImGuiMultiSelectIO*"
+        }
+      ],
+      "argsoriginal": "(ImGuiMultiSelectIO* ms_io)",
+      "call_args": "(ms_io)",
+      "cimguiname": "ImGuiSelectionBasicStorage_ApplyRequests",
+      "defaults": {},
+      "funcname": "ApplyRequests",
+      "location": "imgui:3005",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_ApplyRequests",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectIO*)",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_Clear": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiSelectionBasicStorage_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:3007",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_Contains": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "ImGuiSelectionBasicStorage_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "imgui:3006",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_Contains",
+      "ret": "bool",
+      "signature": "(ImGuiID)const",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_GetNextSelectedItem": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self,void** opaque_it,ImGuiID* out_id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        },
+        {
+          "name": "opaque_it",
+          "type": "void**"
+        },
+        {
+          "name": "out_id",
+          "type": "ImGuiID*"
+        }
+      ],
+      "argsoriginal": "(void** opaque_it,ImGuiID* out_id)",
+      "call_args": "(opaque_it,out_id)",
+      "cimguiname": "ImGuiSelectionBasicStorage_GetNextSelectedItem",
+      "defaults": {},
+      "funcname": "GetNextSelectedItem",
+      "location": "imgui:3010",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_GetNextSelectedItem",
+      "ret": "bool",
+      "signature": "(void**,ImGuiID*)",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_GetStorageIdFromIndex": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self,int idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImGuiSelectionBasicStorage_GetStorageIdFromIndex",
+      "defaults": {},
+      "funcname": "GetStorageIdFromIndex",
+      "location": "imgui:3011",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_GetStorageIdFromIndex",
+      "ret": "ImGuiID",
+      "signature": "(int)",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiSelectionBasicStorage",
+      "location": "imgui:3004",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage",
+      "signature": "()",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_SetItemSelected": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self,ImGuiID id,bool selected)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "selected",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,bool selected)",
+      "call_args": "(id,selected)",
+      "cimguiname": "ImGuiSelectionBasicStorage_SetItemSelected",
+      "defaults": {},
+      "funcname": "SetItemSelected",
+      "location": "imgui:3009",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_SetItemSelected",
+      "ret": "void",
+      "signature": "(ImGuiID,bool)",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_Swap": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self,ImGuiSelectionBasicStorage* r)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        },
+        {
+          "name": "r",
+          "reftoptr": true,
+          "type": "ImGuiSelectionBasicStorage*"
+        }
+      ],
+      "argsoriginal": "(ImGuiSelectionBasicStorage& r)",
+      "call_args": "(*r)",
+      "cimguiname": "ImGuiSelectionBasicStorage_Swap",
+      "defaults": {},
+      "funcname": "Swap",
+      "location": "imgui:3008",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_Swap",
+      "ret": "void",
+      "signature": "(ImGuiSelectionBasicStorage*)",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionBasicStorage_destroy": [
+    {
+      "args": "(ImGuiSelectionBasicStorage* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionBasicStorage*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiSelectionBasicStorage_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3004",
+      "ov_cimguiname": "ImGuiSelectionBasicStorage_destroy",
+      "ret": "void",
+      "signature": "(ImGuiSelectionBasicStorage*)",
+      "stname": "ImGuiSelectionBasicStorage"
+    }
+  ],
+  "ImGuiSelectionExternalStorage_ApplyRequests": [
+    {
+      "args": "(ImGuiSelectionExternalStorage* self,ImGuiMultiSelectIO* ms_io)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionExternalStorage*"
+        },
+        {
+          "name": "ms_io",
+          "type": "ImGuiMultiSelectIO*"
+        }
+      ],
+      "argsoriginal": "(ImGuiMultiSelectIO* ms_io)",
+      "call_args": "(ms_io)",
+      "cimguiname": "ImGuiSelectionExternalStorage_ApplyRequests",
+      "defaults": {},
+      "funcname": "ApplyRequests",
+      "location": "imgui:3024",
+      "ov_cimguiname": "ImGuiSelectionExternalStorage_ApplyRequests",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectIO*)",
+      "stname": "ImGuiSelectionExternalStorage"
+    }
+  ],
+  "ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiSelectionExternalStorage",
+      "location": "imgui:3023",
+      "ov_cimguiname": "ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage",
+      "signature": "()",
+      "stname": "ImGuiSelectionExternalStorage"
+    }
+  ],
+  "ImGuiSelectionExternalStorage_destroy": [
+    {
+      "args": "(ImGuiSelectionExternalStorage* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSelectionExternalStorage*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiSelectionExternalStorage_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3023",
+      "ov_cimguiname": "ImGuiSelectionExternalStorage_destroy",
+      "ret": "void",
+      "signature": "(ImGuiSelectionExternalStorage*)",
+      "stname": "ImGuiSelectionExternalStorage"
+    }
+  ],
+  "ImGuiSettingsHandler_ImGuiSettingsHandler": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiSettingsHandler_ImGuiSettingsHandler",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiSettingsHandler",
+      "location": "imgui_internal:2066",
+      "ov_cimguiname": "ImGuiSettingsHandler_ImGuiSettingsHandler",
+      "signature": "()",
+      "stname": "ImGuiSettingsHandler"
+    }
+  ],
+  "ImGuiSettingsHandler_destroy": [
+    {
+      "args": "(ImGuiSettingsHandler* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiSettingsHandler*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiSettingsHandler_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2066",
+      "ov_cimguiname": "ImGuiSettingsHandler_destroy",
+      "ret": "void",
+      "signature": "(ImGuiSettingsHandler*)",
+      "stname": "ImGuiSettingsHandler"
+    }
+  ],
+  "ImGuiStackLevelInfo_ImGuiStackLevelInfo": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiStackLevelInfo_ImGuiStackLevelInfo",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStackLevelInfo",
+      "location": "imgui_internal:2184",
+      "ov_cimguiname": "ImGuiStackLevelInfo_ImGuiStackLevelInfo",
+      "signature": "()",
+      "stname": "ImGuiStackLevelInfo"
+    }
+  ],
+  "ImGuiStackLevelInfo_destroy": [
+    {
+      "args": "(ImGuiStackLevelInfo* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStackLevelInfo*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiStackLevelInfo_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2184",
+      "ov_cimguiname": "ImGuiStackLevelInfo_destroy",
+      "ret": "void",
+      "signature": "(ImGuiStackLevelInfo*)",
+      "stname": "ImGuiStackLevelInfo"
+    }
+  ],
+  "ImGuiStoragePair_ImGuiStoragePair": [
+    {
+      "args": "(ImGuiID _key,int _val)",
+      "argsT": [
+        {
+          "name": "_key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "_val",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiID _key,int _val)",
+      "call_args": "(_key,_val)",
+      "cimguiname": "ImGuiStoragePair_ImGuiStoragePair",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStoragePair",
+      "location": "imgui:2699",
+      "ov_cimguiname": "ImGuiStoragePair_ImGuiStoragePair_Int",
+      "signature": "(ImGuiID,int)",
+      "stname": "ImGuiStoragePair"
+    },
+    {
+      "args": "(ImGuiID _key,float _val)",
+      "argsT": [
+        {
+          "name": "_key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "_val",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiID _key,float _val)",
+      "call_args": "(_key,_val)",
+      "cimguiname": "ImGuiStoragePair_ImGuiStoragePair",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStoragePair",
+      "location": "imgui:2700",
+      "ov_cimguiname": "ImGuiStoragePair_ImGuiStoragePair_Float",
+      "signature": "(ImGuiID,float)",
+      "stname": "ImGuiStoragePair"
+    },
+    {
+      "args": "(ImGuiID _key,void* _val)",
+      "argsT": [
+        {
+          "name": "_key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "_val",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID _key,void* _val)",
+      "call_args": "(_key,_val)",
+      "cimguiname": "ImGuiStoragePair_ImGuiStoragePair",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStoragePair",
+      "location": "imgui:2701",
+      "ov_cimguiname": "ImGuiStoragePair_ImGuiStoragePair_Ptr",
+      "signature": "(ImGuiID,void*)",
+      "stname": "ImGuiStoragePair"
+    }
+  ],
+  "ImGuiStoragePair_destroy": [
+    {
+      "args": "(ImGuiStoragePair* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStoragePair*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiStoragePair_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2699",
+      "ov_cimguiname": "ImGuiStoragePair_destroy",
+      "ret": "void",
+      "signature": "(ImGuiStoragePair*)",
+      "stname": "ImGuiStoragePair"
+    }
+  ],
+  "ImGuiStorage_BuildSortByKey": [
+    {
+      "args": "(ImGuiStorage* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiStorage_BuildSortByKey",
+      "defaults": {},
+      "funcname": "BuildSortByKey",
+      "location": "imgui:2740",
+      "ov_cimguiname": "ImGuiStorage_BuildSortByKey",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_Clear": [
+    {
+      "args": "(ImGuiStorage* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiStorage_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:2720",
+      "ov_cimguiname": "ImGuiStorage_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetBool": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,bool default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,bool default_val=false)",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetBool",
+      "defaults": {
+        "default_val": "false"
+      },
+      "funcname": "GetBool",
+      "location": "imgui:2723",
+      "ov_cimguiname": "ImGuiStorage_GetBool",
+      "ret": "bool",
+      "signature": "(ImGuiID,bool)const",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetBoolRef": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,bool default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,bool default_val=false)",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetBoolRef",
+      "defaults": {
+        "default_val": "false"
+      },
+      "funcname": "GetBoolRef",
+      "location": "imgui:2735",
+      "ov_cimguiname": "ImGuiStorage_GetBoolRef",
+      "ret": "bool*",
+      "signature": "(ImGuiID,bool)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetFloat": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,float default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,float default_val=0.0f)",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetFloat",
+      "defaults": {
+        "default_val": "0.0f"
+      },
+      "funcname": "GetFloat",
+      "location": "imgui:2725",
+      "ov_cimguiname": "ImGuiStorage_GetFloat",
+      "ret": "float",
+      "signature": "(ImGuiID,float)const",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetFloatRef": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,float default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,float default_val=0.0f)",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetFloatRef",
+      "defaults": {
+        "default_val": "0.0f"
+      },
+      "funcname": "GetFloatRef",
+      "location": "imgui:2736",
+      "ov_cimguiname": "ImGuiStorage_GetFloatRef",
+      "ret": "float*",
+      "signature": "(ImGuiID,float)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetInt": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,int default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,int default_val=0)",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetInt",
+      "defaults": {
+        "default_val": "0"
+      },
+      "funcname": "GetInt",
+      "location": "imgui:2721",
+      "ov_cimguiname": "ImGuiStorage_GetInt",
+      "ret": "int",
+      "signature": "(ImGuiID,int)const",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetIntRef": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,int default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,int default_val=0)",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetIntRef",
+      "defaults": {
+        "default_val": "0"
+      },
+      "funcname": "GetIntRef",
+      "location": "imgui:2734",
+      "ov_cimguiname": "ImGuiStorage_GetIntRef",
+      "ret": "int*",
+      "signature": "(ImGuiID,int)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetVoidPtr": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key)",
+      "call_args": "(key)",
+      "cimguiname": "ImGuiStorage_GetVoidPtr",
+      "defaults": {},
+      "funcname": "GetVoidPtr",
+      "location": "imgui:2727",
+      "ov_cimguiname": "ImGuiStorage_GetVoidPtr",
+      "ret": "void*",
+      "signature": "(ImGuiID)const",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_GetVoidPtrRef": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,void* default_val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "default_val",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,void* default_val=((void*)0))",
+      "call_args": "(key,default_val)",
+      "cimguiname": "ImGuiStorage_GetVoidPtrRef",
+      "defaults": {
+        "default_val": "NULL"
+      },
+      "funcname": "GetVoidPtrRef",
+      "location": "imgui:2737",
+      "ov_cimguiname": "ImGuiStorage_GetVoidPtrRef",
+      "ret": "void**",
+      "signature": "(ImGuiID,void*)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_SetAllInt": [
+    {
+      "args": "(ImGuiStorage* self,int val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "val",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int val)",
+      "call_args": "(val)",
+      "cimguiname": "ImGuiStorage_SetAllInt",
+      "defaults": {},
+      "funcname": "SetAllInt",
+      "location": "imgui:2742",
+      "ov_cimguiname": "ImGuiStorage_SetAllInt",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_SetBool": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,bool val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "val",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,bool val)",
+      "call_args": "(key,val)",
+      "cimguiname": "ImGuiStorage_SetBool",
+      "defaults": {},
+      "funcname": "SetBool",
+      "location": "imgui:2724",
+      "ov_cimguiname": "ImGuiStorage_SetBool",
+      "ret": "void",
+      "signature": "(ImGuiID,bool)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_SetFloat": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,float val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "val",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,float val)",
+      "call_args": "(key,val)",
+      "cimguiname": "ImGuiStorage_SetFloat",
+      "defaults": {},
+      "funcname": "SetFloat",
+      "location": "imgui:2726",
+      "ov_cimguiname": "ImGuiStorage_SetFloat",
+      "ret": "void",
+      "signature": "(ImGuiID,float)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_SetInt": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,int val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "val",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,int val)",
+      "call_args": "(key,val)",
+      "cimguiname": "ImGuiStorage_SetInt",
+      "defaults": {},
+      "funcname": "SetInt",
+      "location": "imgui:2722",
+      "ov_cimguiname": "ImGuiStorage_SetInt",
+      "ret": "void",
+      "signature": "(ImGuiID,int)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStorage_SetVoidPtr": [
+    {
+      "args": "(ImGuiStorage* self,ImGuiID key,void* val)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "val",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,void* val)",
+      "call_args": "(key,val)",
+      "cimguiname": "ImGuiStorage_SetVoidPtr",
+      "defaults": {},
+      "funcname": "SetVoidPtr",
+      "location": "imgui:2728",
+      "ov_cimguiname": "ImGuiStorage_SetVoidPtr",
+      "ret": "void",
+      "signature": "(ImGuiID,void*)",
+      "stname": "ImGuiStorage"
+    }
+  ],
+  "ImGuiStyleMod_ImGuiStyleMod": [
+    {
+      "args": "(ImGuiStyleVar idx,int v)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "v",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,int v)",
+      "call_args": "(idx,v)",
+      "cimguiname": "ImGuiStyleMod_ImGuiStyleMod",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStyleMod",
+      "location": "imgui_internal:1054",
+      "ov_cimguiname": "ImGuiStyleMod_ImGuiStyleMod_Int",
+      "signature": "(ImGuiStyleVar,int)",
+      "stname": "ImGuiStyleMod"
+    },
+    {
+      "args": "(ImGuiStyleVar idx,float v)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "v",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,float v)",
+      "call_args": "(idx,v)",
+      "cimguiname": "ImGuiStyleMod_ImGuiStyleMod",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStyleMod",
+      "location": "imgui_internal:1055",
+      "ov_cimguiname": "ImGuiStyleMod_ImGuiStyleMod_Float",
+      "signature": "(ImGuiStyleVar,float)",
+      "stname": "ImGuiStyleMod"
+    },
+    {
+      "args": "(ImGuiStyleVar idx,ImVec2 v)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "v",
+          "type": "ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,ImVec2 v)",
+      "call_args": "(idx,v)",
+      "cimguiname": "ImGuiStyleMod_ImGuiStyleMod",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStyleMod",
+      "location": "imgui_internal:1056",
+      "ov_cimguiname": "ImGuiStyleMod_ImGuiStyleMod_Vec2",
+      "signature": "(ImGuiStyleVar,ImVec2)",
+      "stname": "ImGuiStyleMod"
+    }
+  ],
+  "ImGuiStyleMod_destroy": [
+    {
+      "args": "(ImGuiStyleMod* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStyleMod*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiStyleMod_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1054",
+      "ov_cimguiname": "ImGuiStyleMod_destroy",
+      "ret": "void",
+      "signature": "(ImGuiStyleMod*)",
+      "stname": "ImGuiStyleMod"
+    }
+  ],
+  "ImGuiStyle_ImGuiStyle": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiStyle_ImGuiStyle",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiStyle",
+      "location": "imgui:2260",
+      "ov_cimguiname": "ImGuiStyle_ImGuiStyle",
+      "signature": "()",
+      "stname": "ImGuiStyle"
+    }
+  ],
+  "ImGuiStyle_ScaleAllSizes": [
+    {
+      "args": "(ImGuiStyle* self,float scale_factor)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStyle*"
+        },
+        {
+          "name": "scale_factor",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float scale_factor)",
+      "call_args": "(scale_factor)",
+      "cimguiname": "ImGuiStyle_ScaleAllSizes",
+      "defaults": {},
+      "funcname": "ScaleAllSizes",
+      "location": "imgui:2261",
+      "ov_cimguiname": "ImGuiStyle_ScaleAllSizes",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": "ImGuiStyle"
+    }
+  ],
+  "ImGuiStyle_destroy": [
+    {
+      "args": "(ImGuiStyle* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiStyle*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiStyle_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2260",
+      "ov_cimguiname": "ImGuiStyle_destroy",
+      "ret": "void",
+      "signature": "(ImGuiStyle*)",
+      "stname": "ImGuiStyle"
+    }
+  ],
+  "ImGuiTabBar_ImGuiTabBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTabBar_ImGuiTabBar",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTabBar",
+      "location": "imgui_internal:2889",
+      "ov_cimguiname": "ImGuiTabBar_ImGuiTabBar",
+      "signature": "()",
+      "stname": "ImGuiTabBar"
+    }
+  ],
+  "ImGuiTabBar_destroy": [
+    {
+      "args": "(ImGuiTabBar* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTabBar*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTabBar_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2889",
+      "ov_cimguiname": "ImGuiTabBar_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*)",
+      "stname": "ImGuiTabBar"
+    }
+  ],
+  "ImGuiTabItem_ImGuiTabItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTabItem_ImGuiTabItem",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTabItem",
+      "location": "imgui_internal:2848",
+      "ov_cimguiname": "ImGuiTabItem_ImGuiTabItem",
+      "signature": "()",
+      "stname": "ImGuiTabItem"
+    }
+  ],
+  "ImGuiTabItem_destroy": [
+    {
+      "args": "(ImGuiTabItem* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTabItem*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTabItem_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2848",
+      "ov_cimguiname": "ImGuiTabItem_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTabItem*)",
+      "stname": "ImGuiTabItem"
+    }
+  ],
+  "ImGuiTableColumnSettings_ImGuiTableColumnSettings": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableColumnSettings_ImGuiTableColumnSettings",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableColumnSettings",
+      "location": "imgui_internal:3157",
+      "ov_cimguiname": "ImGuiTableColumnSettings_ImGuiTableColumnSettings",
+      "signature": "()",
+      "stname": "ImGuiTableColumnSettings"
+    }
+  ],
+  "ImGuiTableColumnSettings_destroy": [
+    {
+      "args": "(ImGuiTableColumnSettings* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableColumnSettings*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableColumnSettings_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:3157",
+      "ov_cimguiname": "ImGuiTableColumnSettings_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableColumnSettings*)",
+      "stname": "ImGuiTableColumnSettings"
+    }
+  ],
+  "ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableColumnSortSpecs",
+      "location": "imgui:2083",
+      "ov_cimguiname": "ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs",
+      "signature": "()",
+      "stname": "ImGuiTableColumnSortSpecs"
+    }
+  ],
+  "ImGuiTableColumnSortSpecs_destroy": [
+    {
+      "args": "(ImGuiTableColumnSortSpecs* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableColumnSortSpecs*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableColumnSortSpecs_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2083",
+      "ov_cimguiname": "ImGuiTableColumnSortSpecs_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableColumnSortSpecs*)",
+      "stname": "ImGuiTableColumnSortSpecs"
+    }
+  ],
+  "ImGuiTableColumn_ImGuiTableColumn": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableColumn_ImGuiTableColumn",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableColumn",
+      "location": "imgui_internal:2952",
+      "ov_cimguiname": "ImGuiTableColumn_ImGuiTableColumn",
+      "signature": "()",
+      "stname": "ImGuiTableColumn"
+    }
+  ],
+  "ImGuiTableColumn_destroy": [
+    {
+      "args": "(ImGuiTableColumn* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableColumn*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableColumn_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2952",
+      "ov_cimguiname": "ImGuiTableColumn_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableColumn*)",
+      "stname": "ImGuiTableColumn"
+    }
+  ],
+  "ImGuiTableInstanceData_ImGuiTableInstanceData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableInstanceData_ImGuiTableInstanceData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableInstanceData",
+      "location": "imgui_internal:2995",
+      "ov_cimguiname": "ImGuiTableInstanceData_ImGuiTableInstanceData",
+      "signature": "()",
+      "stname": "ImGuiTableInstanceData"
+    }
+  ],
+  "ImGuiTableInstanceData_destroy": [
+    {
+      "args": "(ImGuiTableInstanceData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableInstanceData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableInstanceData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2995",
+      "ov_cimguiname": "ImGuiTableInstanceData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableInstanceData*)",
+      "stname": "ImGuiTableInstanceData"
+    }
+  ],
+  "ImGuiTableSettings_GetColumnSettings": [
+    {
+      "args": "(ImGuiTableSettings* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableSettings*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableSettings_GetColumnSettings",
+      "defaults": {},
+      "funcname": "GetColumnSettings",
+      "location": "imgui_internal:3180",
+      "ov_cimguiname": "ImGuiTableSettings_GetColumnSettings",
+      "ret": "ImGuiTableColumnSettings*",
+      "signature": "()",
+      "stname": "ImGuiTableSettings"
+    }
+  ],
+  "ImGuiTableSettings_ImGuiTableSettings": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableSettings_ImGuiTableSettings",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableSettings",
+      "location": "imgui_internal:3179",
+      "ov_cimguiname": "ImGuiTableSettings_ImGuiTableSettings",
+      "signature": "()",
+      "stname": "ImGuiTableSettings"
+    }
+  ],
+  "ImGuiTableSettings_destroy": [
+    {
+      "args": "(ImGuiTableSettings* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableSettings*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableSettings_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:3179",
+      "ov_cimguiname": "ImGuiTableSettings_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableSettings*)",
+      "stname": "ImGuiTableSettings"
+    }
+  ],
+  "ImGuiTableSortSpecs_ImGuiTableSortSpecs": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableSortSpecs_ImGuiTableSortSpecs",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableSortSpecs",
+      "location": "imgui:2072",
+      "ov_cimguiname": "ImGuiTableSortSpecs_ImGuiTableSortSpecs",
+      "signature": "()",
+      "stname": "ImGuiTableSortSpecs"
+    }
+  ],
+  "ImGuiTableSortSpecs_destroy": [
+    {
+      "args": "(ImGuiTableSortSpecs* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableSortSpecs*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableSortSpecs_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2072",
+      "ov_cimguiname": "ImGuiTableSortSpecs_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableSortSpecs*)",
+      "stname": "ImGuiTableSortSpecs"
+    }
+  ],
+  "ImGuiTableTempData_ImGuiTableTempData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTableTempData_ImGuiTableTempData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTableTempData",
+      "location": "imgui_internal:3142",
+      "ov_cimguiname": "ImGuiTableTempData_ImGuiTableTempData",
+      "signature": "()",
+      "stname": "ImGuiTableTempData"
+    }
+  ],
+  "ImGuiTableTempData_destroy": [
+    {
+      "args": "(ImGuiTableTempData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTableTempData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTableTempData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:3142",
+      "ov_cimguiname": "ImGuiTableTempData_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTableTempData*)",
+      "stname": "ImGuiTableTempData"
+    }
+  ],
+  "ImGuiTable_ImGuiTable": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTable_ImGuiTable",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTable",
+      "location": "imgui_internal:3114",
+      "ov_cimguiname": "ImGuiTable_ImGuiTable",
+      "signature": "()",
+      "stname": "ImGuiTable"
+    }
+  ],
+  "ImGuiTable_destroy": [
+    {
+      "args": "(ImGuiTable* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTable_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:3115",
+      "ov_cimguiname": "ImGuiTable_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": "ImGuiTable"
+    }
+  ],
+  "ImGuiTextBuffer_ImGuiTextBuffer": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_ImGuiTextBuffer",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTextBuffer",
+      "location": "imgui:2680",
+      "ov_cimguiname": "ImGuiTextBuffer_ImGuiTextBuffer",
+      "signature": "()",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_append": [
+    {
+      "args": "(ImGuiTextBuffer* self,const char* str,const char* str_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        },
+        {
+          "name": "str",
+          "type": "const char*"
+        },
+        {
+          "name": "str_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str,const char* str_end=((void*)0))",
+      "call_args": "(str,str_end)",
+      "cimguiname": "ImGuiTextBuffer_append",
+      "defaults": {
+        "str_end": "NULL"
+      },
+      "funcname": "append",
+      "location": "imgui:2689",
+      "ov_cimguiname": "ImGuiTextBuffer_append",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_appendf": [
+    {
+      "args": "(struct ImGuiTextBuffer* buffer, const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "type": "struct ImGuiTextBuffer*"
+        },
+        {
+          "name": "fmt",
+          "type": " const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(struct ImGuiTextBuffer* buffer, const char* fmt, ...)",
+      "call_args": "(buffer,fmt,...)",
+      "cimguiname": "ImGuiTextBuffer_appendf",
+      "defaults": {},
+      "funcname": "appendf",
+      "isvararg": "...)",
+      "location": "imgui:2690",
+      "manual": true,
+      "ov_cimguiname": "ImGuiTextBuffer_appendf",
+      "ret": "void",
+      "signature": "(struct ImGuiTextBuffer*, const char*,...)",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_appendfv": [
+    {
+      "args": "(ImGuiTextBuffer* self,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "ImGuiTextBuffer_appendfv",
+      "defaults": {},
+      "funcname": "appendfv",
+      "location": "imgui:2691",
+      "ov_cimguiname": "ImGuiTextBuffer_appendfv",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_begin": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_begin",
+      "defaults": {},
+      "funcname": "begin",
+      "location": "imgui:2682",
+      "ov_cimguiname": "ImGuiTextBuffer_begin",
+      "ret": "const char*",
+      "signature": "()const",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_c_str": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_c_str",
+      "defaults": {},
+      "funcname": "c_str",
+      "location": "imgui:2688",
+      "ov_cimguiname": "ImGuiTextBuffer_c_str",
+      "ret": "const char*",
+      "signature": "()const",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_clear": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_clear",
+      "defaults": {},
+      "funcname": "clear",
+      "location": "imgui:2686",
+      "ov_cimguiname": "ImGuiTextBuffer_clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_destroy": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTextBuffer_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2680",
+      "ov_cimguiname": "ImGuiTextBuffer_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTextBuffer*)",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_empty": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_empty",
+      "defaults": {},
+      "funcname": "empty",
+      "location": "imgui:2685",
+      "ov_cimguiname": "ImGuiTextBuffer_empty",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_end": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_end",
+      "defaults": {},
+      "funcname": "end",
+      "location": "imgui:2683",
+      "ov_cimguiname": "ImGuiTextBuffer_end",
+      "ret": "const char*",
+      "signature": "()const",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_reserve": [
+    {
+      "args": "(ImGuiTextBuffer* self,int capacity)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        },
+        {
+          "name": "capacity",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int capacity)",
+      "call_args": "(capacity)",
+      "cimguiname": "ImGuiTextBuffer_reserve",
+      "defaults": {},
+      "funcname": "reserve",
+      "location": "imgui:2687",
+      "ov_cimguiname": "ImGuiTextBuffer_reserve",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextBuffer_size": [
+    {
+      "args": "(ImGuiTextBuffer* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextBuffer*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextBuffer_size",
+      "defaults": {},
+      "funcname": "size",
+      "location": "imgui:2684",
+      "ov_cimguiname": "ImGuiTextBuffer_size",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImGuiTextBuffer"
+    }
+  ],
+  "ImGuiTextFilter_Build": [
+    {
+      "args": "(ImGuiTextFilter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextFilter*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextFilter_Build",
+      "defaults": {},
+      "funcname": "Build",
+      "location": "imgui:2653",
+      "ov_cimguiname": "ImGuiTextFilter_Build",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextFilter_Clear": [
+    {
+      "args": "(ImGuiTextFilter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextFilter*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextFilter_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui:2654",
+      "ov_cimguiname": "ImGuiTextFilter_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextFilter_Draw": [
+    {
+      "args": "(ImGuiTextFilter* self,const char* label,float width)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextFilter*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const char* label=\"Filter(inc,-exc)\",float width=0.0f)",
+      "call_args": "(label,width)",
+      "cimguiname": "ImGuiTextFilter_Draw",
+      "defaults": {
+        "label": "\"Filter(inc,-exc)\"",
+        "width": "0.0f"
+      },
+      "funcname": "Draw",
+      "location": "imgui:2651",
+      "ov_cimguiname": "ImGuiTextFilter_Draw",
+      "ret": "bool",
+      "signature": "(const char*,float)",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextFilter_ImGuiTextFilter": [
+    {
+      "args": "(const char* default_filter)",
+      "argsT": [
+        {
+          "name": "default_filter",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* default_filter=\"\")",
+      "call_args": "(default_filter)",
+      "cimguiname": "ImGuiTextFilter_ImGuiTextFilter",
+      "constructor": true,
+      "defaults": {
+        "default_filter": "\"\""
+      },
+      "funcname": "ImGuiTextFilter",
+      "location": "imgui:2650",
+      "ov_cimguiname": "ImGuiTextFilter_ImGuiTextFilter",
+      "signature": "(const char*)",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextFilter_IsActive": [
+    {
+      "args": "(ImGuiTextFilter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextFilter*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextFilter_IsActive",
+      "defaults": {},
+      "funcname": "IsActive",
+      "location": "imgui:2655",
+      "ov_cimguiname": "ImGuiTextFilter_IsActive",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextFilter_PassFilter": [
+    {
+      "args": "(ImGuiTextFilter* self,const char* text,const char* text_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextFilter*"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
+      "call_args": "(text,text_end)",
+      "cimguiname": "ImGuiTextFilter_PassFilter",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "PassFilter",
+      "location": "imgui:2652",
+      "ov_cimguiname": "ImGuiTextFilter_PassFilter",
+      "ret": "bool",
+      "signature": "(const char*,const char*)const",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextFilter_destroy": [
+    {
+      "args": "(ImGuiTextFilter* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextFilter*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTextFilter_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2650",
+      "ov_cimguiname": "ImGuiTextFilter_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTextFilter*)",
+      "stname": "ImGuiTextFilter"
+    }
+  ],
+  "ImGuiTextIndex_append": [
+    {
+      "args": "(ImGuiTextIndex* self,const char* base,int old_size,int new_size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextIndex*"
+        },
+        {
+          "name": "base",
+          "type": "const char*"
+        },
+        {
+          "name": "old_size",
+          "type": "int"
+        },
+        {
+          "name": "new_size",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* base,int old_size,int new_size)",
+      "call_args": "(base,old_size,new_size)",
+      "cimguiname": "ImGuiTextIndex_append",
+      "defaults": {},
+      "funcname": "append",
+      "location": "imgui_internal:743",
+      "ov_cimguiname": "ImGuiTextIndex_append",
+      "ret": "void",
+      "signature": "(const char*,int,int)",
+      "stname": "ImGuiTextIndex"
+    }
+  ],
+  "ImGuiTextIndex_clear": [
+    {
+      "args": "(ImGuiTextIndex* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextIndex*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextIndex_clear",
+      "defaults": {},
+      "funcname": "clear",
+      "location": "imgui_internal:739",
+      "ov_cimguiname": "ImGuiTextIndex_clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiTextIndex"
+    }
+  ],
+  "ImGuiTextIndex_get_line_begin": [
+    {
+      "args": "(ImGuiTextIndex* self,const char* base,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextIndex*"
+        },
+        {
+          "name": "base",
+          "type": "const char*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* base,int n)",
+      "call_args": "(base,n)",
+      "cimguiname": "ImGuiTextIndex_get_line_begin",
+      "defaults": {},
+      "funcname": "get_line_begin",
+      "location": "imgui_internal:741",
+      "ov_cimguiname": "ImGuiTextIndex_get_line_begin",
+      "ret": "const char*",
+      "signature": "(const char*,int)",
+      "stname": "ImGuiTextIndex"
+    }
+  ],
+  "ImGuiTextIndex_get_line_end": [
+    {
+      "args": "(ImGuiTextIndex* self,const char* base,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextIndex*"
+        },
+        {
+          "name": "base",
+          "type": "const char*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* base,int n)",
+      "call_args": "(base,n)",
+      "cimguiname": "ImGuiTextIndex_get_line_end",
+      "defaults": {},
+      "funcname": "get_line_end",
+      "location": "imgui_internal:742",
+      "ov_cimguiname": "ImGuiTextIndex_get_line_end",
+      "ret": "const char*",
+      "signature": "(const char*,int)",
+      "stname": "ImGuiTextIndex"
+    }
+  ],
+  "ImGuiTextIndex_size": [
+    {
+      "args": "(ImGuiTextIndex* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextIndex*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextIndex_size",
+      "defaults": {},
+      "funcname": "size",
+      "location": "imgui_internal:740",
+      "ov_cimguiname": "ImGuiTextIndex_size",
+      "ret": "int",
+      "signature": "()",
+      "stname": "ImGuiTextIndex"
+    }
+  ],
+  "ImGuiTextRange_ImGuiTextRange": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextRange_ImGuiTextRange",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTextRange",
+      "location": "imgui:2663",
+      "ov_cimguiname": "ImGuiTextRange_ImGuiTextRange_Nil",
+      "signature": "()",
+      "stname": "ImGuiTextRange"
+    },
+    {
+      "args": "(const char* _b,const char* _e)",
+      "argsT": [
+        {
+          "name": "_b",
+          "type": "const char*"
+        },
+        {
+          "name": "_e",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* _b,const char* _e)",
+      "call_args": "(_b,_e)",
+      "cimguiname": "ImGuiTextRange_ImGuiTextRange",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTextRange",
+      "location": "imgui:2664",
+      "ov_cimguiname": "ImGuiTextRange_ImGuiTextRange_Str",
+      "signature": "(const char*,const char*)",
+      "stname": "ImGuiTextRange"
+    }
+  ],
+  "ImGuiTextRange_destroy": [
+    {
+      "args": "(ImGuiTextRange* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextRange*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTextRange_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2663",
+      "ov_cimguiname": "ImGuiTextRange_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTextRange*)",
+      "stname": "ImGuiTextRange"
+    }
+  ],
+  "ImGuiTextRange_empty": [
+    {
+      "args": "(ImGuiTextRange* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextRange*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTextRange_empty",
+      "defaults": {},
+      "funcname": "empty",
+      "location": "imgui:2665",
+      "ov_cimguiname": "ImGuiTextRange_empty",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImGuiTextRange"
+    }
+  ],
+  "ImGuiTextRange_split": [
+    {
+      "args": "(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTextRange*"
+        },
+        {
+          "name": "separator",
+          "type": "char"
+        },
+        {
+          "name": "out",
+          "type": "ImVector_ImGuiTextRange*"
+        }
+      ],
+      "argsoriginal": "(char separator,ImVector<ImGuiTextRange>* out)",
+      "call_args": "(separator,out)",
+      "cimguiname": "ImGuiTextRange_split",
+      "defaults": {},
+      "funcname": "split",
+      "location": "imgui:2666",
+      "ov_cimguiname": "ImGuiTextRange_split",
+      "ret": "void",
+      "signature": "(char,ImVector_ImGuiTextRange*)const",
+      "stname": "ImGuiTextRange"
+    }
+  ],
+  "ImGuiTypingSelectState_Clear": [
+    {
+      "args": "(ImGuiTypingSelectState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTypingSelectState*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTypingSelectState_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui_internal:1688",
+      "ov_cimguiname": "ImGuiTypingSelectState_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiTypingSelectState"
+    }
+  ],
+  "ImGuiTypingSelectState_ImGuiTypingSelectState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiTypingSelectState_ImGuiTypingSelectState",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiTypingSelectState",
+      "location": "imgui_internal:1687",
+      "ov_cimguiname": "ImGuiTypingSelectState_ImGuiTypingSelectState",
+      "signature": "()",
+      "stname": "ImGuiTypingSelectState"
+    }
+  ],
+  "ImGuiTypingSelectState_destroy": [
+    {
+      "args": "(ImGuiTypingSelectState* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiTypingSelectState*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiTypingSelectState_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:1687",
+      "ov_cimguiname": "ImGuiTypingSelectState_destroy",
+      "ret": "void",
+      "signature": "(ImGuiTypingSelectState*)",
+      "stname": "ImGuiTypingSelectState"
+    }
+  ],
+  "ImGuiViewportP_CalcWorkRectPos": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        },
+        {
+          "name": "inset_min",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& inset_min)",
+      "call_args": "(inset_min)",
+      "cimguiname": "ImGuiViewportP_CalcWorkRectPos",
+      "defaults": {},
+      "funcname": "CalcWorkRectPos",
+      "location": "imgui_internal:2018",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewportP_CalcWorkRectPos",
+      "ret": "void",
+      "signature": "(const ImVec2)const",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_CalcWorkRectSize": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min,const ImVec2 inset_max)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        },
+        {
+          "name": "inset_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "inset_max",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& inset_min,const ImVec2& inset_max)",
+      "call_args": "(inset_min,inset_max)",
+      "cimguiname": "ImGuiViewportP_CalcWorkRectSize",
+      "defaults": {},
+      "funcname": "CalcWorkRectSize",
+      "location": "imgui_internal:2019",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewportP_CalcWorkRectSize",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2)const",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_ClearRequestFlags": [
+    {
+      "args": "(ImGuiViewportP* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewportP_ClearRequestFlags",
+      "defaults": {},
+      "funcname": "ClearRequestFlags",
+      "location": "imgui_internal:2015",
+      "ov_cimguiname": "ImGuiViewportP_ClearRequestFlags",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_GetBuildWorkRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiViewportP* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewportP_GetBuildWorkRect",
+      "defaults": {},
+      "funcname": "GetBuildWorkRect",
+      "location": "imgui_internal:2025",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewportP_GetBuildWorkRect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_GetMainRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiViewportP* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewportP_GetMainRect",
+      "defaults": {},
+      "funcname": "GetMainRect",
+      "location": "imgui_internal:2023",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewportP_GetMainRect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_GetWorkRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiViewportP* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewportP_GetWorkRect",
+      "defaults": {},
+      "funcname": "GetWorkRect",
+      "location": "imgui_internal:2024",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewportP_GetWorkRect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_ImGuiViewportP": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewportP_ImGuiViewportP",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiViewportP",
+      "location": "imgui_internal:2013",
+      "ov_cimguiname": "ImGuiViewportP_ImGuiViewportP",
+      "signature": "()",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_UpdateWorkRect": [
+    {
+      "args": "(ImGuiViewportP* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewportP_UpdateWorkRect",
+      "defaults": {},
+      "funcname": "UpdateWorkRect",
+      "location": "imgui_internal:2020",
+      "ov_cimguiname": "ImGuiViewportP_UpdateWorkRect",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewportP_destroy": [
+    {
+      "args": "(ImGuiViewportP* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiViewportP_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2014",
+      "ov_cimguiname": "ImGuiViewportP_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiViewportP*)",
+      "stname": "ImGuiViewportP"
+    }
+  ],
+  "ImGuiViewport_GetCenter": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiViewport* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewport*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewport_GetCenter",
+      "defaults": {},
+      "funcname": "GetCenter",
+      "location": "imgui:3662",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewport_GetCenter",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiViewport"
+    }
+  ],
+  "ImGuiViewport_GetWorkCenter": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiViewport* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiViewport*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewport_GetWorkCenter",
+      "defaults": {},
+      "funcname": "GetWorkCenter",
+      "location": "imgui:3663",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiViewport_GetWorkCenter",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiViewport"
+    }
+  ],
+  "ImGuiViewport_ImGuiViewport": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiViewport_ImGuiViewport",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiViewport",
+      "location": "imgui:3658",
+      "ov_cimguiname": "ImGuiViewport_ImGuiViewport",
+      "signature": "()",
+      "stname": "ImGuiViewport"
+    }
+  ],
+  "ImGuiViewport_destroy": [
+    {
+      "args": "(ImGuiViewport* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiViewport*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiViewport_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:3659",
+      "ov_cimguiname": "ImGuiViewport_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiViewport*)",
+      "stname": "ImGuiViewport"
+    }
+  ],
+  "ImGuiWindowClass_ImGuiWindowClass": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindowClass_ImGuiWindowClass",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiWindowClass",
+      "location": "imgui:2601",
+      "ov_cimguiname": "ImGuiWindowClass_ImGuiWindowClass",
+      "signature": "()",
+      "stname": "ImGuiWindowClass"
+    }
+  ],
+  "ImGuiWindowClass_destroy": [
+    {
+      "args": "(ImGuiWindowClass* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindowClass*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiWindowClass_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2601",
+      "ov_cimguiname": "ImGuiWindowClass_destroy",
+      "ret": "void",
+      "signature": "(ImGuiWindowClass*)",
+      "stname": "ImGuiWindowClass"
+    }
+  ],
+  "ImGuiWindowSettings_GetName": [
+    {
+      "args": "(ImGuiWindowSettings* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindowSettings*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindowSettings_GetName",
+      "defaults": {},
+      "funcname": "GetName",
+      "location": "imgui_internal:2051",
+      "ov_cimguiname": "ImGuiWindowSettings_GetName",
+      "ret": "char*",
+      "signature": "()",
+      "stname": "ImGuiWindowSettings"
+    }
+  ],
+  "ImGuiWindowSettings_ImGuiWindowSettings": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindowSettings_ImGuiWindowSettings",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiWindowSettings",
+      "location": "imgui_internal:2050",
+      "ov_cimguiname": "ImGuiWindowSettings_ImGuiWindowSettings",
+      "signature": "()",
+      "stname": "ImGuiWindowSettings"
+    }
+  ],
+  "ImGuiWindowSettings_destroy": [
+    {
+      "args": "(ImGuiWindowSettings* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindowSettings*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiWindowSettings_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2050",
+      "ov_cimguiname": "ImGuiWindowSettings_destroy",
+      "ret": "void",
+      "signature": "(ImGuiWindowSettings*)",
+      "stname": "ImGuiWindowSettings"
+    }
+  ],
+  "ImGuiWindow_CalcFontSize": [
+    {
+      "args": "(ImGuiWindow* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindow_CalcFontSize",
+      "defaults": {},
+      "funcname": "CalcFontSize",
+      "location": "imgui_internal:2805",
+      "ov_cimguiname": "ImGuiWindow_CalcFontSize",
+      "ret": "float",
+      "signature": "()const",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_GetID": [
+    {
+      "args": "(ImGuiWindow* self,const char* str,const char* str_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "str",
+          "type": "const char*"
+        },
+        {
+          "name": "str_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str,const char* str_end=((void*)0))",
+      "call_args": "(str,str_end)",
+      "cimguiname": "ImGuiWindow_GetID",
+      "defaults": {
+        "str_end": "NULL"
+      },
+      "funcname": "GetID",
+      "location": "imgui_internal:2797",
+      "ov_cimguiname": "ImGuiWindow_GetID_Str",
+      "ret": "ImGuiID",
+      "signature": "(const char*,const char*)",
+      "stname": "ImGuiWindow"
+    },
+    {
+      "args": "(ImGuiWindow* self,const void* ptr)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "ptr",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(const void* ptr)",
+      "call_args": "(ptr)",
+      "cimguiname": "ImGuiWindow_GetID",
+      "defaults": {},
+      "funcname": "GetID",
+      "location": "imgui_internal:2798",
+      "ov_cimguiname": "ImGuiWindow_GetID_Ptr",
+      "ret": "ImGuiID",
+      "signature": "(const void*)",
+      "stname": "ImGuiWindow"
+    },
+    {
+      "args": "(ImGuiWindow* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImGuiWindow_GetID",
+      "defaults": {},
+      "funcname": "GetID",
+      "location": "imgui_internal:2799",
+      "ov_cimguiname": "ImGuiWindow_GetID_Int",
+      "ret": "ImGuiID",
+      "signature": "(int)",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_GetIDFromPos": [
+    {
+      "args": "(ImGuiWindow* self,const ImVec2 p_abs)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "p_abs",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p_abs)",
+      "call_args": "(p_abs)",
+      "cimguiname": "ImGuiWindow_GetIDFromPos",
+      "defaults": {},
+      "funcname": "GetIDFromPos",
+      "location": "imgui_internal:2800",
+      "ov_cimguiname": "ImGuiWindow_GetIDFromPos",
+      "ret": "ImGuiID",
+      "signature": "(const ImVec2)",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_GetIDFromRectangle": [
+    {
+      "args": "(ImGuiWindow* self,const ImRect r_abs)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "r_abs",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r_abs)",
+      "call_args": "(r_abs)",
+      "cimguiname": "ImGuiWindow_GetIDFromRectangle",
+      "defaults": {},
+      "funcname": "GetIDFromRectangle",
+      "location": "imgui_internal:2801",
+      "ov_cimguiname": "ImGuiWindow_GetIDFromRectangle",
+      "ret": "ImGuiID",
+      "signature": "(const ImRect)",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_ImGuiWindow": [
+    {
+      "args": "(ImGuiContext* context,const char* name)",
+      "argsT": [
+        {
+          "name": "context",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* context,const char* name)",
+      "call_args": "(context,name)",
+      "cimguiname": "ImGuiWindow_ImGuiWindow",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGuiWindow",
+      "location": "imgui_internal:2793",
+      "ov_cimguiname": "ImGuiWindow_ImGuiWindow",
+      "signature": "(ImGuiContext*,const char*)",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_MenuBarRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindow_MenuBarRect",
+      "defaults": {},
+      "funcname": "MenuBarRect",
+      "location": "imgui_internal:2807",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiWindow_MenuBarRect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_Rect": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindow_Rect",
+      "defaults": {},
+      "funcname": "Rect",
+      "location": "imgui_internal:2804",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiWindow_Rect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_TitleBarRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuiWindow_TitleBarRect",
+      "defaults": {},
+      "funcname": "TitleBarRect",
+      "location": "imgui_internal:2806",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImGuiWindow_TitleBarRect",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImGuiWindow_destroy": [
+    {
+      "args": "(ImGuiWindow* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGuiWindow_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:2795",
+      "ov_cimguiname": "ImGuiWindow_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": "ImGuiWindow"
+    }
+  ],
+  "ImPool_Add": [
+    {
+      "args": "(ImPool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPool_Add",
+      "defaults": {},
+      "funcname": "Add",
+      "location": "imgui_internal:696",
+      "ov_cimguiname": "ImPool_Add",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_Clear": [
+    {
+      "args": "(ImPool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPool_Clear",
+      "defaults": {},
+      "funcname": "Clear",
+      "location": "imgui_internal:695",
+      "ov_cimguiname": "ImPool_Clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_Contains": [
+    {
+      "args": "(ImPool* self,const T* p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "p",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* p)",
+      "call_args": "(p)",
+      "cimguiname": "ImPool_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "imgui_internal:694",
+      "ov_cimguiname": "ImPool_Contains",
+      "ret": "bool",
+      "signature": "(const T*)const",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetAliveCount": [
+    {
+      "args": "(ImPool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPool_GetAliveCount",
+      "defaults": {},
+      "funcname": "GetAliveCount",
+      "location": "imgui_internal:703",
+      "ov_cimguiname": "ImPool_GetAliveCount",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetBufSize": [
+    {
+      "args": "(ImPool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPool_GetBufSize",
+      "defaults": {},
+      "funcname": "GetBufSize",
+      "location": "imgui_internal:704",
+      "ov_cimguiname": "ImPool_GetBufSize",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetByIndex": [
+    {
+      "args": "(ImPool* self,ImPoolIdx n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "n",
+          "type": "ImPoolIdx"
+        }
+      ],
+      "argsoriginal": "(ImPoolIdx n)",
+      "call_args": "(n)",
+      "cimguiname": "ImPool_GetByIndex",
+      "defaults": {},
+      "funcname": "GetByIndex",
+      "location": "imgui_internal:691",
+      "ov_cimguiname": "ImPool_GetByIndex",
+      "ret": "T*",
+      "signature": "(ImPoolIdx)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetByKey": [
+    {
+      "args": "(ImPool* self,ImGuiID key)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key)",
+      "call_args": "(key)",
+      "cimguiname": "ImPool_GetByKey",
+      "defaults": {},
+      "funcname": "GetByKey",
+      "location": "imgui_internal:690",
+      "ov_cimguiname": "ImPool_GetByKey",
+      "ret": "T*",
+      "signature": "(ImGuiID)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetIndex": [
+    {
+      "args": "(ImPool* self,const T* p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "p",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* p)",
+      "call_args": "(p)",
+      "cimguiname": "ImPool_GetIndex",
+      "defaults": {},
+      "funcname": "GetIndex",
+      "location": "imgui_internal:692",
+      "ov_cimguiname": "ImPool_GetIndex",
+      "ret": "ImPoolIdx",
+      "signature": "(const T*)const",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetMapSize": [
+    {
+      "args": "(ImPool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPool_GetMapSize",
+      "defaults": {},
+      "funcname": "GetMapSize",
+      "location": "imgui_internal:705",
+      "ov_cimguiname": "ImPool_GetMapSize",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_GetOrAddByKey": [
+    {
+      "args": "(ImPool* self,ImGuiID key)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key)",
+      "call_args": "(key)",
+      "cimguiname": "ImPool_GetOrAddByKey",
+      "defaults": {},
+      "funcname": "GetOrAddByKey",
+      "location": "imgui_internal:693",
+      "ov_cimguiname": "ImPool_GetOrAddByKey",
+      "ret": "T*",
+      "signature": "(ImGuiID)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_ImPool": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPool_ImPool",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPool",
+      "location": "imgui_internal:688",
+      "ov_cimguiname": "ImPool_ImPool",
+      "signature": "()",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_Remove": [
+    {
+      "args": "(ImPool* self,ImGuiID key,const T* p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "p",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,const T* p)",
+      "call_args": "(key,p)",
+      "cimguiname": "ImPool_Remove",
+      "defaults": {},
+      "funcname": "Remove",
+      "location": "imgui_internal:697",
+      "ov_cimguiname": "ImPool_Remove_TPtr",
+      "ret": "void",
+      "signature": "(ImGuiID,const T*)",
+      "stname": "ImPool",
+      "templated": true
+    },
+    {
+      "args": "(ImPool* self,ImGuiID key,ImPoolIdx idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "idx",
+          "type": "ImPoolIdx"
+        }
+      ],
+      "argsoriginal": "(ImGuiID key,ImPoolIdx idx)",
+      "call_args": "(key,idx)",
+      "cimguiname": "ImPool_Remove",
+      "defaults": {},
+      "funcname": "Remove",
+      "location": "imgui_internal:698",
+      "ov_cimguiname": "ImPool_Remove_PoolIdx",
+      "ret": "void",
+      "signature": "(ImGuiID,ImPoolIdx)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_Reserve": [
+    {
+      "args": "(ImPool* self,int capacity)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "capacity",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int capacity)",
+      "call_args": "(capacity)",
+      "cimguiname": "ImPool_Reserve",
+      "defaults": {},
+      "funcname": "Reserve",
+      "location": "imgui_internal:699",
+      "ov_cimguiname": "ImPool_Reserve",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_TryGetMapData": [
+    {
+      "args": "(ImPool* self,ImPoolIdx n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        },
+        {
+          "name": "n",
+          "type": "ImPoolIdx"
+        }
+      ],
+      "argsoriginal": "(ImPoolIdx n)",
+      "call_args": "(n)",
+      "cimguiname": "ImPool_TryGetMapData",
+      "defaults": {},
+      "funcname": "TryGetMapData",
+      "location": "imgui_internal:706",
+      "ov_cimguiname": "ImPool_TryGetMapData",
+      "ret": "T*",
+      "signature": "(ImPoolIdx)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImPool_destroy": [
+    {
+      "args": "(ImPool* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPool*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPool_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:689",
+      "ov_cimguiname": "ImPool_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImPool*)",
+      "stname": "ImPool",
+      "templated": true
+    }
+  ],
+  "ImRect_Add": [
+    {
+      "args": "(ImRect* self,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p)",
+      "call_args": "(p)",
+      "cimguiname": "ImRect_Add",
+      "defaults": {},
+      "funcname": "Add",
+      "location": "imgui_internal:559",
+      "ov_cimguiname": "ImRect_Add_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImRect"
+    },
+    {
+      "args": "(ImRect* self,const ImRect r)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r)",
+      "call_args": "(r)",
+      "cimguiname": "ImRect_Add",
+      "defaults": {},
+      "funcname": "Add",
+      "location": "imgui_internal:560",
+      "ov_cimguiname": "ImRect_Add_Rect",
+      "ret": "void",
+      "signature": "(const ImRect)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_ClipWith": [
+    {
+      "args": "(ImRect* self,const ImRect r)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r)",
+      "call_args": "(r)",
+      "cimguiname": "ImRect_ClipWith",
+      "defaults": {},
+      "funcname": "ClipWith",
+      "location": "imgui_internal:566",
+      "ov_cimguiname": "ImRect_ClipWith",
+      "ret": "void",
+      "signature": "(const ImRect)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_ClipWithFull": [
+    {
+      "args": "(ImRect* self,const ImRect r)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r)",
+      "call_args": "(r)",
+      "cimguiname": "ImRect_ClipWithFull",
+      "defaults": {},
+      "funcname": "ClipWithFull",
+      "location": "imgui_internal:567",
+      "ov_cimguiname": "ImRect_ClipWithFull",
+      "ret": "void",
+      "signature": "(const ImRect)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_Contains": [
+    {
+      "args": "(ImRect* self,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p)",
+      "call_args": "(p)",
+      "cimguiname": "ImRect_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "imgui_internal:555",
+      "ov_cimguiname": "ImRect_Contains_Vec2",
+      "ret": "bool",
+      "signature": "(const ImVec2)const",
+      "stname": "ImRect"
+    },
+    {
+      "args": "(ImRect* self,const ImRect r)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r)",
+      "call_args": "(r)",
+      "cimguiname": "ImRect_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "imgui_internal:556",
+      "ov_cimguiname": "ImRect_Contains_Rect",
+      "ret": "bool",
+      "signature": "(const ImRect)const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_ContainsWithPad": [
+    {
+      "args": "(ImRect* self,const ImVec2 p,const ImVec2 pad)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "pad",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p,const ImVec2& pad)",
+      "call_args": "(p,pad)",
+      "cimguiname": "ImRect_ContainsWithPad",
+      "defaults": {},
+      "funcname": "ContainsWithPad",
+      "location": "imgui_internal:557",
+      "ov_cimguiname": "ImRect_ContainsWithPad",
+      "ret": "bool",
+      "signature": "(const ImVec2,const ImVec2)const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_Expand": [
+    {
+      "args": "(ImRect* self,const float amount)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "amount",
+          "type": "const float"
+        }
+      ],
+      "argsoriginal": "(const float amount)",
+      "call_args": "(amount)",
+      "cimguiname": "ImRect_Expand",
+      "defaults": {},
+      "funcname": "Expand",
+      "location": "imgui_internal:561",
+      "ov_cimguiname": "ImRect_Expand_Float",
+      "ret": "void",
+      "signature": "(const float)",
+      "stname": "ImRect"
+    },
+    {
+      "args": "(ImRect* self,const ImVec2 amount)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "amount",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& amount)",
+      "call_args": "(amount)",
+      "cimguiname": "ImRect_Expand",
+      "defaults": {},
+      "funcname": "Expand",
+      "location": "imgui_internal:562",
+      "ov_cimguiname": "ImRect_Expand_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_Floor": [
+    {
+      "args": "(ImRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_Floor",
+      "defaults": {},
+      "funcname": "Floor",
+      "location": "imgui_internal:568",
+      "ov_cimguiname": "ImRect_Floor",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetArea": [
+    {
+      "args": "(ImRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetArea",
+      "defaults": {},
+      "funcname": "GetArea",
+      "location": "imgui_internal:550",
+      "ov_cimguiname": "ImRect_GetArea",
+      "ret": "float",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetBL": [
+    {
+      "args": "(ImVec2 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetBL",
+      "defaults": {},
+      "funcname": "GetBL",
+      "location": "imgui_internal:553",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_GetBL",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetBR": [
+    {
+      "args": "(ImVec2 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetBR",
+      "defaults": {},
+      "funcname": "GetBR",
+      "location": "imgui_internal:554",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_GetBR",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetCenter": [
+    {
+      "args": "(ImVec2 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetCenter",
+      "defaults": {},
+      "funcname": "GetCenter",
+      "location": "imgui_internal:546",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_GetCenter",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetHeight": [
+    {
+      "args": "(ImRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetHeight",
+      "defaults": {},
+      "funcname": "GetHeight",
+      "location": "imgui_internal:549",
+      "ov_cimguiname": "ImRect_GetHeight",
+      "ret": "float",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetSize": [
+    {
+      "args": "(ImVec2 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetSize",
+      "defaults": {},
+      "funcname": "GetSize",
+      "location": "imgui_internal:547",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_GetSize",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetTL": [
+    {
+      "args": "(ImVec2 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetTL",
+      "defaults": {},
+      "funcname": "GetTL",
+      "location": "imgui_internal:551",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_GetTL",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetTR": [
+    {
+      "args": "(ImVec2 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetTR",
+      "defaults": {},
+      "funcname": "GetTR",
+      "location": "imgui_internal:552",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_GetTR",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_GetWidth": [
+    {
+      "args": "(ImRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_GetWidth",
+      "defaults": {},
+      "funcname": "GetWidth",
+      "location": "imgui_internal:548",
+      "ov_cimguiname": "ImRect_GetWidth",
+      "ret": "float",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_ImRect": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_ImRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImRect",
+      "location": "imgui_internal:541",
+      "ov_cimguiname": "ImRect_ImRect_Nil",
+      "signature": "()",
+      "stname": "ImRect"
+    },
+    {
+      "args": "(const ImVec2 min,const ImVec2 max)",
+      "argsT": [
+        {
+          "name": "min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "max",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& min,const ImVec2& max)",
+      "call_args": "(min,max)",
+      "cimguiname": "ImRect_ImRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImRect",
+      "location": "imgui_internal:542",
+      "ov_cimguiname": "ImRect_ImRect_Vec2",
+      "signature": "(const ImVec2,const ImVec2)",
+      "stname": "ImRect"
+    },
+    {
+      "args": "(const ImVec4 v)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImRect_ImRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImRect",
+      "location": "imgui_internal:543",
+      "ov_cimguiname": "ImRect_ImRect_Vec4",
+      "signature": "(const ImVec4)",
+      "stname": "ImRect"
+    },
+    {
+      "args": "(float x1,float y1,float x2,float y2)",
+      "argsT": [
+        {
+          "name": "x1",
+          "type": "float"
+        },
+        {
+          "name": "y1",
+          "type": "float"
+        },
+        {
+          "name": "x2",
+          "type": "float"
+        },
+        {
+          "name": "y2",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x1,float y1,float x2,float y2)",
+      "call_args": "(x1,y1,x2,y2)",
+      "cimguiname": "ImRect_ImRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImRect",
+      "location": "imgui_internal:544",
+      "ov_cimguiname": "ImRect_ImRect_Float",
+      "signature": "(float,float,float,float)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_IsInverted": [
+    {
+      "args": "(ImRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_IsInverted",
+      "defaults": {},
+      "funcname": "IsInverted",
+      "location": "imgui_internal:569",
+      "ov_cimguiname": "ImRect_IsInverted",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_Overlaps": [
+    {
+      "args": "(ImRect* self,const ImRect r)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r)",
+      "call_args": "(r)",
+      "cimguiname": "ImRect_Overlaps",
+      "defaults": {},
+      "funcname": "Overlaps",
+      "location": "imgui_internal:558",
+      "ov_cimguiname": "ImRect_Overlaps",
+      "ret": "bool",
+      "signature": "(const ImRect)const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_ToVec4": [
+    {
+      "args": "(ImVec4 *pOut,ImRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImRect_ToVec4",
+      "defaults": {},
+      "funcname": "ToVec4",
+      "location": "imgui_internal:570",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImRect_ToVec4",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_Translate": [
+    {
+      "args": "(ImRect* self,const ImVec2 d)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "d",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& d)",
+      "call_args": "(d)",
+      "cimguiname": "ImRect_Translate",
+      "defaults": {},
+      "funcname": "Translate",
+      "location": "imgui_internal:563",
+      "ov_cimguiname": "ImRect_Translate",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_TranslateX": [
+    {
+      "args": "(ImRect* self,float dx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "dx",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float dx)",
+      "call_args": "(dx)",
+      "cimguiname": "ImRect_TranslateX",
+      "defaults": {},
+      "funcname": "TranslateX",
+      "location": "imgui_internal:564",
+      "ov_cimguiname": "ImRect_TranslateX",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_TranslateY": [
+    {
+      "args": "(ImRect* self,float dy)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        },
+        {
+          "name": "dy",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float dy)",
+      "call_args": "(dy)",
+      "cimguiname": "ImRect_TranslateY",
+      "defaults": {},
+      "funcname": "TranslateY",
+      "location": "imgui_internal:565",
+      "ov_cimguiname": "ImRect_TranslateY",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImRect_destroy": [
+    {
+      "args": "(ImRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImRect*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImRect_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:541",
+      "ov_cimguiname": "ImRect_destroy",
+      "ret": "void",
+      "signature": "(ImRect*)",
+      "stname": "ImRect"
+    }
+  ],
+  "ImSpanAllocator_GetArenaSizeInBytes": [
+    {
+      "args": "(ImSpanAllocator* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpanAllocator*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpanAllocator_GetArenaSizeInBytes",
+      "defaults": {},
+      "funcname": "GetArenaSizeInBytes",
+      "location": "imgui_internal:668",
+      "ov_cimguiname": "ImSpanAllocator_GetArenaSizeInBytes",
+      "ret": "int",
+      "signature": "()",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpanAllocator_GetSpanPtrBegin": [
+    {
+      "args": "(ImSpanAllocator* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpanAllocator*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImSpanAllocator_GetSpanPtrBegin",
+      "defaults": {},
+      "funcname": "GetSpanPtrBegin",
+      "location": "imgui_internal:670",
+      "ov_cimguiname": "ImSpanAllocator_GetSpanPtrBegin",
+      "ret": "void*",
+      "signature": "(int)",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpanAllocator_GetSpanPtrEnd": [
+    {
+      "args": "(ImSpanAllocator* self,int n)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpanAllocator*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n)",
+      "call_args": "(n)",
+      "cimguiname": "ImSpanAllocator_GetSpanPtrEnd",
+      "defaults": {},
+      "funcname": "GetSpanPtrEnd",
+      "location": "imgui_internal:671",
+      "ov_cimguiname": "ImSpanAllocator_GetSpanPtrEnd",
+      "ret": "void*",
+      "signature": "(int)",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpanAllocator_ImSpanAllocator": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpanAllocator_ImSpanAllocator",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImSpanAllocator",
+      "location": "imgui_internal:666",
+      "ov_cimguiname": "ImSpanAllocator_ImSpanAllocator",
+      "signature": "()",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpanAllocator_Reserve": [
+    {
+      "args": "(ImSpanAllocator* self,int n,size_t sz,int a)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpanAllocator*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "sz",
+          "type": "size_t"
+        },
+        {
+          "name": "a",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int n,size_t sz,int a=4)",
+      "call_args": "(n,sz,a)",
+      "cimguiname": "ImSpanAllocator_Reserve",
+      "defaults": {
+        "a": "4"
+      },
+      "funcname": "Reserve",
+      "location": "imgui_internal:667",
+      "ov_cimguiname": "ImSpanAllocator_Reserve",
+      "ret": "void",
+      "signature": "(int,size_t,int)",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpanAllocator_SetArenaBasePtr": [
+    {
+      "args": "(ImSpanAllocator* self,void* base_ptr)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpanAllocator*"
+        },
+        {
+          "name": "base_ptr",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void* base_ptr)",
+      "call_args": "(base_ptr)",
+      "cimguiname": "ImSpanAllocator_SetArenaBasePtr",
+      "defaults": {},
+      "funcname": "SetArenaBasePtr",
+      "location": "imgui_internal:669",
+      "ov_cimguiname": "ImSpanAllocator_SetArenaBasePtr",
+      "ret": "void",
+      "signature": "(void*)",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpanAllocator_destroy": [
+    {
+      "args": "(ImSpanAllocator* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpanAllocator*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImSpanAllocator_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:666",
+      "ov_cimguiname": "ImSpanAllocator_destroy",
+      "ret": "void",
+      "signature": "(ImSpanAllocator*)",
+      "stname": "ImSpanAllocator",
+      "templated": true
+    }
+  ],
+  "ImSpan_ImSpan": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_ImSpan",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImSpan",
+      "location": "imgui_internal:634",
+      "ov_cimguiname": "ImSpan_ImSpan_Nil",
+      "signature": "()",
+      "stname": "ImSpan",
+      "templated": true
+    },
+    {
+      "args": "(T* data,int size)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "T*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(T* data,int size)",
+      "call_args": "(data,size)",
+      "cimguiname": "ImSpan_ImSpan",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImSpan",
+      "location": "imgui_internal:635",
+      "ov_cimguiname": "ImSpan_ImSpan_TPtrInt",
+      "signature": "(T*,int)",
+      "stname": "ImSpan",
+      "templated": true
+    },
+    {
+      "args": "(T* data,T* data_end)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "T*"
+        },
+        {
+          "name": "data_end",
+          "type": "T*"
+        }
+      ],
+      "argsoriginal": "(T* data,T* data_end)",
+      "call_args": "(data,data_end)",
+      "cimguiname": "ImSpan_ImSpan",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImSpan",
+      "location": "imgui_internal:636",
+      "ov_cimguiname": "ImSpan_ImSpan_TPtrTPtr",
+      "signature": "(T*,T*)",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_begin": [
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_begin",
+      "defaults": {},
+      "funcname": "begin",
+      "location": "imgui_internal:645",
+      "ov_cimguiname": "ImSpan_begin_Nil",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImSpan",
+      "templated": true
+    },
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_begin",
+      "defaults": {},
+      "funcname": "begin",
+      "location": "imgui_internal:646",
+      "ov_cimguiname": "ImSpan_begin__const",
+      "ret": "const T*",
+      "signature": "()const",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_destroy": [
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImSpan_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:634",
+      "ov_cimguiname": "ImSpan_destroy",
+      "ret": "void",
+      "signature": "(ImSpan*)",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_end": [
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_end",
+      "defaults": {},
+      "funcname": "end",
+      "location": "imgui_internal:647",
+      "ov_cimguiname": "ImSpan_end_Nil",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImSpan",
+      "templated": true
+    },
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_end",
+      "defaults": {},
+      "funcname": "end",
+      "location": "imgui_internal:648",
+      "ov_cimguiname": "ImSpan_end__const",
+      "ret": "const T*",
+      "signature": "()const",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_index_from_ptr": [
+    {
+      "args": "(ImSpan* self,const T* it)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        },
+        {
+          "name": "it",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* it)",
+      "call_args": "(it)",
+      "cimguiname": "ImSpan_index_from_ptr",
+      "defaults": {},
+      "funcname": "index_from_ptr",
+      "location": "imgui_internal:651",
+      "ov_cimguiname": "ImSpan_index_from_ptr",
+      "ret": "int",
+      "signature": "(const T*)const",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_set": [
+    {
+      "args": "(ImSpan* self,T* data,int size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        },
+        {
+          "name": "data",
+          "type": "T*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(T* data,int size)",
+      "call_args": "(data,size)",
+      "cimguiname": "ImSpan_set",
+      "defaults": {},
+      "funcname": "set",
+      "location": "imgui_internal:638",
+      "ov_cimguiname": "ImSpan_set_Int",
+      "ret": "void",
+      "signature": "(T*,int)",
+      "stname": "ImSpan",
+      "templated": true
+    },
+    {
+      "args": "(ImSpan* self,T* data,T* data_end)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        },
+        {
+          "name": "data",
+          "type": "T*"
+        },
+        {
+          "name": "data_end",
+          "type": "T*"
+        }
+      ],
+      "argsoriginal": "(T* data,T* data_end)",
+      "call_args": "(data,data_end)",
+      "cimguiname": "ImSpan_set",
+      "defaults": {},
+      "funcname": "set",
+      "location": "imgui_internal:639",
+      "ov_cimguiname": "ImSpan_set_TPtr",
+      "ret": "void",
+      "signature": "(T*,T*)",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_size": [
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_size",
+      "defaults": {},
+      "funcname": "size",
+      "location": "imgui_internal:640",
+      "ov_cimguiname": "ImSpan_size",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImSpan_size_in_bytes": [
+    {
+      "args": "(ImSpan* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImSpan*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImSpan_size_in_bytes",
+      "defaults": {},
+      "funcname": "size_in_bytes",
+      "location": "imgui_internal:641",
+      "ov_cimguiname": "ImSpan_size_in_bytes",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImSpan",
+      "templated": true
+    }
+  ],
+  "ImVec1_ImVec1": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVec1_ImVec1",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec1",
+      "location": "imgui_internal:521",
+      "ov_cimguiname": "ImVec1_ImVec1_Nil",
+      "signature": "()",
+      "stname": "ImVec1"
+    },
+    {
+      "args": "(float _x)",
+      "argsT": [
+        {
+          "name": "_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float _x)",
+      "call_args": "(_x)",
+      "cimguiname": "ImVec1_ImVec1",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec1",
+      "location": "imgui_internal:522",
+      "ov_cimguiname": "ImVec1_ImVec1_Float",
+      "signature": "(float)",
+      "stname": "ImVec1"
+    }
+  ],
+  "ImVec1_destroy": [
+    {
+      "args": "(ImVec1* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVec1*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImVec1_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:521",
+      "ov_cimguiname": "ImVec1_destroy",
+      "ret": "void",
+      "signature": "(ImVec1*)",
+      "stname": "ImVec1"
+    }
+  ],
+  "ImVec2_ImVec2": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVec2_ImVec2",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec2",
+      "location": "imgui:299",
+      "ov_cimguiname": "ImVec2_ImVec2_Nil",
+      "signature": "()",
+      "stname": "ImVec2"
+    },
+    {
+      "args": "(float _x,float _y)",
+      "argsT": [
+        {
+          "name": "_x",
+          "type": "float"
+        },
+        {
+          "name": "_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float _x,float _y)",
+      "call_args": "(_x,_y)",
+      "cimguiname": "ImVec2_ImVec2",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec2",
+      "location": "imgui:300",
+      "ov_cimguiname": "ImVec2_ImVec2_Float",
+      "signature": "(float,float)",
+      "stname": "ImVec2"
+    }
+  ],
+  "ImVec2_destroy": [
+    {
+      "args": "(ImVec2* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVec2*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImVec2_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:299",
+      "ov_cimguiname": "ImVec2_destroy",
+      "ret": "void",
+      "signature": "(ImVec2*)",
+      "stname": "ImVec2"
+    }
+  ],
+  "ImVec2ih_ImVec2ih": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVec2ih_ImVec2ih",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec2ih",
+      "location": "imgui_internal:529",
+      "ov_cimguiname": "ImVec2ih_ImVec2ih_Nil",
+      "signature": "()",
+      "stname": "ImVec2ih"
+    },
+    {
+      "args": "(short _x,short _y)",
+      "argsT": [
+        {
+          "name": "_x",
+          "type": "short"
+        },
+        {
+          "name": "_y",
+          "type": "short"
+        }
+      ],
+      "argsoriginal": "(short _x,short _y)",
+      "call_args": "(_x,_y)",
+      "cimguiname": "ImVec2ih_ImVec2ih",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec2ih",
+      "location": "imgui_internal:530",
+      "ov_cimguiname": "ImVec2ih_ImVec2ih_short",
+      "signature": "(short,short)",
+      "stname": "ImVec2ih"
+    },
+    {
+      "args": "(const ImVec2 rhs)",
+      "argsT": [
+        {
+          "name": "rhs",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& rhs)",
+      "call_args": "(rhs)",
+      "cimguiname": "ImVec2ih_ImVec2ih",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec2ih",
+      "location": "imgui_internal:531",
+      "ov_cimguiname": "ImVec2ih_ImVec2ih_Vec2",
+      "signature": "(const ImVec2)",
+      "stname": "ImVec2ih"
+    }
+  ],
+  "ImVec2ih_destroy": [
+    {
+      "args": "(ImVec2ih* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVec2ih*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImVec2ih_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_internal:529",
+      "ov_cimguiname": "ImVec2ih_destroy",
+      "ret": "void",
+      "signature": "(ImVec2ih*)",
+      "stname": "ImVec2ih"
+    }
+  ],
+  "ImVec4_ImVec4": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVec4_ImVec4",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec4",
+      "location": "imgui:312",
+      "ov_cimguiname": "ImVec4_ImVec4_Nil",
+      "signature": "()",
+      "stname": "ImVec4"
+    },
+    {
+      "args": "(float _x,float _y,float _z,float _w)",
+      "argsT": [
+        {
+          "name": "_x",
+          "type": "float"
+        },
+        {
+          "name": "_y",
+          "type": "float"
+        },
+        {
+          "name": "_z",
+          "type": "float"
+        },
+        {
+          "name": "_w",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float _x,float _y,float _z,float _w)",
+      "call_args": "(_x,_y,_z,_w)",
+      "cimguiname": "ImVec4_ImVec4",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVec4",
+      "location": "imgui:313",
+      "ov_cimguiname": "ImVec4_ImVec4_Float",
+      "signature": "(float,float,float,float)",
+      "stname": "ImVec4"
+    }
+  ],
+  "ImVec4_destroy": [
+    {
+      "args": "(ImVec4* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVec4*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImVec4_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:312",
+      "ov_cimguiname": "ImVec4_destroy",
+      "ret": "void",
+      "signature": "(ImVec4*)",
+      "stname": "ImVec4"
+    }
+  ],
+  "ImVector_ImVector": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_ImVector",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVector",
+      "location": "imgui:2140",
+      "ov_cimguiname": "ImVector_ImVector_Nil",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(const ImVector_T  src)",
+      "argsT": [
+        {
+          "name": "src",
+          "type": "const ImVector_T "
+        }
+      ],
+      "argsoriginal": "(const ImVector<T>& src)",
+      "call_args": "(src)",
+      "cimguiname": "ImVector_ImVector",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImVector",
+      "location": "imgui:2141",
+      "ov_cimguiname": "ImVector_ImVector_Vector_T_",
+      "signature": "(const ImVector_T )",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector__grow_capacity": [
+    {
+      "args": "(ImVector* self,int sz)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "sz",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int sz)",
+      "call_args": "(sz)",
+      "cimguiname": "ImVector__grow_capacity",
+      "defaults": {},
+      "funcname": "_grow_capacity",
+      "location": "imgui:2167",
+      "ov_cimguiname": "ImVector__grow_capacity",
+      "ret": "int",
+      "signature": "(int)const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_back": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_back",
+      "defaults": {},
+      "funcname": "back",
+      "location": "imgui:2163",
+      "ov_cimguiname": "ImVector_back_Nil",
+      "ret": "T*",
+      "retref": "&",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_back",
+      "defaults": {},
+      "funcname": "back",
+      "location": "imgui:2164",
+      "ov_cimguiname": "ImVector_back__const",
+      "ret": "const T*",
+      "retref": "&",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_begin": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_begin",
+      "defaults": {},
+      "funcname": "begin",
+      "location": "imgui:2157",
+      "ov_cimguiname": "ImVector_begin_Nil",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_begin",
+      "defaults": {},
+      "funcname": "begin",
+      "location": "imgui:2158",
+      "ov_cimguiname": "ImVector_begin__const",
+      "ret": "const T*",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_capacity": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_capacity",
+      "defaults": {},
+      "funcname": "capacity",
+      "location": "imgui:2153",
+      "ov_cimguiname": "ImVector_capacity",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_clear": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_clear",
+      "defaults": {},
+      "funcname": "clear",
+      "location": "imgui:2145",
+      "ov_cimguiname": "ImVector_clear",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_clear_delete": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_clear_delete",
+      "defaults": {},
+      "funcname": "clear_delete",
+      "location": "imgui:2146",
+      "ov_cimguiname": "ImVector_clear_delete",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_clear_destruct": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_clear_destruct",
+      "defaults": {},
+      "funcname": "clear_destruct",
+      "location": "imgui:2147",
+      "ov_cimguiname": "ImVector_clear_destruct",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_contains": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_contains",
+      "defaults": {},
+      "funcname": "contains",
+      "location": "imgui:2182",
+      "ov_cimguiname": "ImVector_contains",
+      "ret": "bool",
+      "signature": "(const T)const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_destroy": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImVector_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui:2143",
+      "ov_cimguiname": "ImVector_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImVector*)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_empty": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_empty",
+      "defaults": {},
+      "funcname": "empty",
+      "location": "imgui:2149",
+      "ov_cimguiname": "ImVector_empty",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_end": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_end",
+      "defaults": {},
+      "funcname": "end",
+      "location": "imgui:2159",
+      "ov_cimguiname": "ImVector_end_Nil",
+      "ret": "T*",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_end",
+      "defaults": {},
+      "funcname": "end",
+      "location": "imgui:2160",
+      "ov_cimguiname": "ImVector_end__const",
+      "ret": "const T*",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_erase": [
+    {
+      "args": "(ImVector* self,const T* it)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "it",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* it)",
+      "call_args": "(it)",
+      "cimguiname": "ImVector_erase",
+      "defaults": {},
+      "funcname": "erase",
+      "location": "imgui:2178",
+      "ov_cimguiname": "ImVector_erase_Nil",
+      "ret": "T*",
+      "signature": "(const T*)",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self,const T* it,const T* it_last)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "it",
+          "type": "const T*"
+        },
+        {
+          "name": "it_last",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* it,const T* it_last)",
+      "call_args": "(it,it_last)",
+      "cimguiname": "ImVector_erase",
+      "defaults": {},
+      "funcname": "erase",
+      "location": "imgui:2179",
+      "ov_cimguiname": "ImVector_erase_TPtr",
+      "ret": "T*",
+      "signature": "(const T*,const T*)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_erase_unsorted": [
+    {
+      "args": "(ImVector* self,const T* it)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "it",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* it)",
+      "call_args": "(it)",
+      "cimguiname": "ImVector_erase_unsorted",
+      "defaults": {},
+      "funcname": "erase_unsorted",
+      "location": "imgui:2180",
+      "ov_cimguiname": "ImVector_erase_unsorted",
+      "ret": "T*",
+      "signature": "(const T*)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_find": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_find",
+      "defaults": {},
+      "funcname": "find",
+      "location": "imgui:2183",
+      "ov_cimguiname": "ImVector_find_Nil",
+      "ret": "T*",
+      "signature": "(const T)",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_find",
+      "defaults": {},
+      "funcname": "find",
+      "location": "imgui:2184",
+      "ov_cimguiname": "ImVector_find__const",
+      "ret": "const T*",
+      "signature": "(const T)const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_find_erase": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_find_erase",
+      "defaults": {},
+      "funcname": "find_erase",
+      "location": "imgui:2186",
+      "ov_cimguiname": "ImVector_find_erase",
+      "ret": "bool",
+      "signature": "(const T)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_find_erase_unsorted": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_find_erase_unsorted",
+      "defaults": {},
+      "funcname": "find_erase_unsorted",
+      "location": "imgui:2187",
+      "ov_cimguiname": "ImVector_find_erase_unsorted",
+      "ret": "bool",
+      "signature": "(const T)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_find_index": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_find_index",
+      "defaults": {},
+      "funcname": "find_index",
+      "location": "imgui:2185",
+      "ov_cimguiname": "ImVector_find_index",
+      "ret": "int",
+      "signature": "(const T)const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_front": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_front",
+      "defaults": {},
+      "funcname": "front",
+      "location": "imgui:2161",
+      "ov_cimguiname": "ImVector_front_Nil",
+      "ret": "T*",
+      "retref": "&",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_front",
+      "defaults": {},
+      "funcname": "front",
+      "location": "imgui:2162",
+      "ov_cimguiname": "ImVector_front__const",
+      "ret": "const T*",
+      "retref": "&",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_index_from_ptr": [
+    {
+      "args": "(ImVector* self,const T* it)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "it",
+          "type": "const T*"
+        }
+      ],
+      "argsoriginal": "(const T* it)",
+      "call_args": "(it)",
+      "cimguiname": "ImVector_index_from_ptr",
+      "defaults": {},
+      "funcname": "index_from_ptr",
+      "location": "imgui:2188",
+      "ov_cimguiname": "ImVector_index_from_ptr",
+      "ret": "int",
+      "signature": "(const T*)const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_insert": [
+    {
+      "args": "(ImVector* self,const T* it,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "it",
+          "type": "const T*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T* it,const T& v)",
+      "call_args": "(it,v)",
+      "cimguiname": "ImVector_insert",
+      "defaults": {},
+      "funcname": "insert",
+      "location": "imgui:2181",
+      "ov_cimguiname": "ImVector_insert",
+      "ret": "T*",
+      "signature": "(const T*,const T)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_max_size": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_max_size",
+      "defaults": {},
+      "funcname": "max_size",
+      "location": "imgui:2152",
+      "ov_cimguiname": "ImVector_max_size",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_pop_back": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_pop_back",
+      "defaults": {},
+      "funcname": "pop_back",
+      "location": "imgui:2176",
+      "ov_cimguiname": "ImVector_pop_back",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_push_back": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_push_back",
+      "defaults": {},
+      "funcname": "push_back",
+      "location": "imgui:2175",
+      "ov_cimguiname": "ImVector_push_back",
+      "ret": "void",
+      "signature": "(const T)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_push_front": [
+    {
+      "args": "(ImVector* self,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(const T& v)",
+      "call_args": "(v)",
+      "cimguiname": "ImVector_push_front",
+      "defaults": {},
+      "funcname": "push_front",
+      "location": "imgui:2177",
+      "ov_cimguiname": "ImVector_push_front",
+      "ret": "void",
+      "signature": "(const T)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_reserve": [
+    {
+      "args": "(ImVector* self,int new_capacity)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "new_capacity",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int new_capacity)",
+      "call_args": "(new_capacity)",
+      "cimguiname": "ImVector_reserve",
+      "defaults": {},
+      "funcname": "reserve",
+      "location": "imgui:2171",
+      "ov_cimguiname": "ImVector_reserve",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_reserve_discard": [
+    {
+      "args": "(ImVector* self,int new_capacity)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "new_capacity",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int new_capacity)",
+      "call_args": "(new_capacity)",
+      "cimguiname": "ImVector_reserve_discard",
+      "defaults": {},
+      "funcname": "reserve_discard",
+      "location": "imgui:2172",
+      "ov_cimguiname": "ImVector_reserve_discard",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_resize": [
+    {
+      "args": "(ImVector* self,int new_size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "new_size",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int new_size)",
+      "call_args": "(new_size)",
+      "cimguiname": "ImVector_resize",
+      "defaults": {},
+      "funcname": "resize",
+      "location": "imgui:2168",
+      "ov_cimguiname": "ImVector_resize_Nil",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImVector",
+      "templated": true
+    },
+    {
+      "args": "(ImVector* self,int new_size,const T v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "new_size",
+          "type": "int"
+        },
+        {
+          "name": "v",
+          "type": "const T"
+        }
+      ],
+      "argsoriginal": "(int new_size,const T& v)",
+      "call_args": "(new_size,v)",
+      "cimguiname": "ImVector_resize",
+      "defaults": {},
+      "funcname": "resize",
+      "location": "imgui:2169",
+      "ov_cimguiname": "ImVector_resize_T",
+      "ret": "void",
+      "signature": "(int,const T)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_shrink": [
+    {
+      "args": "(ImVector* self,int new_size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "new_size",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int new_size)",
+      "call_args": "(new_size)",
+      "cimguiname": "ImVector_shrink",
+      "defaults": {},
+      "funcname": "shrink",
+      "location": "imgui:2170",
+      "ov_cimguiname": "ImVector_shrink",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_size": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_size",
+      "defaults": {},
+      "funcname": "size",
+      "location": "imgui:2150",
+      "ov_cimguiname": "ImVector_size",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_size_in_bytes": [
+    {
+      "args": "(ImVector* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImVector_size_in_bytes",
+      "defaults": {},
+      "funcname": "size_in_bytes",
+      "location": "imgui:2151",
+      "ov_cimguiname": "ImVector_size_in_bytes",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "ImVector_swap": [
+    {
+      "args": "(ImVector* self,ImVector_T * rhs)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImVector*"
+        },
+        {
+          "name": "rhs",
+          "reftoptr": true,
+          "type": "ImVector_T *"
+        }
+      ],
+      "argsoriginal": "(ImVector<T>& rhs)",
+      "call_args": "(*rhs)",
+      "cimguiname": "ImVector_swap",
+      "defaults": {},
+      "funcname": "swap",
+      "location": "imgui:2165",
+      "ov_cimguiname": "ImVector_swap",
+      "ret": "void",
+      "signature": "(ImVector_T *)",
+      "stname": "ImVector",
+      "templated": true
+    }
+  ],
+  "igAcceptDragDropPayload": [
+    {
+      "args": "(const char* type,ImGuiDragDropFlags flags)",
+      "argsT": [
+        {
+          "name": "type",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDragDropFlags"
+        }
+      ],
+      "argsoriginal": "(const char* type,ImGuiDragDropFlags flags=0)",
+      "call_args": "(type,flags)",
+      "cimguiname": "igAcceptDragDropPayload",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "AcceptDragDropPayload",
+      "location": "imgui:915",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igAcceptDragDropPayload",
+      "ret": "const ImGuiPayload*",
+      "signature": "(const char*,ImGuiDragDropFlags)",
+      "stname": ""
+    }
+  ],
+  "igActivateItemByID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igActivateItemByID",
+      "defaults": {},
+      "funcname": "ActivateItemByID",
+      "location": "imgui_internal:3391",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igActivateItemByID",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igAddContextHook": [
+    {
+      "args": "(ImGuiContext* context,const ImGuiContextHook* hook)",
+      "argsT": [
+        {
+          "name": "context",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "hook",
+          "type": "const ImGuiContextHook*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* context,const ImGuiContextHook* hook)",
+      "call_args": "(context,hook)",
+      "cimguiname": "igAddContextHook",
+      "defaults": {},
+      "funcname": "AddContextHook",
+      "location": "imgui_internal:3252",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igAddContextHook",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiContext*,const ImGuiContextHook*)",
+      "stname": ""
+    }
+  ],
+  "igAddDrawListToDrawDataEx": [
+    {
+      "args": "(ImDrawData* draw_data,ImVector_ImDrawListPtr* out_list,ImDrawList* draw_list)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        },
+        {
+          "name": "out_list",
+          "type": "ImVector_ImDrawListPtr*"
+        },
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data,ImVector<ImDrawList*>* out_list,ImDrawList* draw_list)",
+      "call_args": "(draw_data,out_list,draw_list)",
+      "cimguiname": "igAddDrawListToDrawDataEx",
+      "defaults": {},
+      "funcname": "AddDrawListToDrawDataEx",
+      "location": "imgui_internal:3236",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igAddDrawListToDrawDataEx",
+      "ret": "void",
+      "signature": "(ImDrawData*,ImVector_ImDrawListPtr*,ImDrawList*)",
+      "stname": ""
+    }
+  ],
+  "igAddSettingsHandler": [
+    {
+      "args": "(const ImGuiSettingsHandler* handler)",
+      "argsT": [
+        {
+          "name": "handler",
+          "type": "const ImGuiSettingsHandler*"
+        }
+      ],
+      "argsoriginal": "(const ImGuiSettingsHandler* handler)",
+      "call_args": "(handler)",
+      "cimguiname": "igAddSettingsHandler",
+      "defaults": {},
+      "funcname": "AddSettingsHandler",
+      "location": "imgui_internal:3269",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igAddSettingsHandler",
+      "ret": "void",
+      "signature": "(const ImGuiSettingsHandler*)",
+      "stname": ""
+    }
+  ],
+  "igAlignTextToFramePadding": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igAlignTextToFramePadding",
+      "defaults": {},
+      "funcname": "AlignTextToFramePadding",
+      "location": "imgui:511",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igAlignTextToFramePadding",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igArrowButton": [
+    {
+      "args": "(const char* str_id,ImGuiDir dir)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "dir",
+          "type": "ImGuiDir"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiDir dir)",
+      "call_args": "(str_id,dir)",
+      "cimguiname": "igArrowButton",
+      "defaults": {},
+      "funcname": "ArrowButton",
+      "location": "imgui:560",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igArrowButton",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDir)",
+      "stname": ""
+    }
+  ],
+  "igArrowButtonEx": [
+    {
+      "args": "(const char* str_id,ImGuiDir dir,ImVec2 size_arg,ImGuiButtonFlags flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "size_arg",
+          "type": "ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiButtonFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiDir dir,ImVec2 size_arg,ImGuiButtonFlags flags=0)",
+      "call_args": "(str_id,dir,size_arg,flags)",
+      "cimguiname": "igArrowButtonEx",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ArrowButtonEx",
+      "location": "imgui_internal:3694",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igArrowButtonEx",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDir,ImVec2,ImGuiButtonFlags)",
+      "stname": ""
+    }
+  ],
+  "igBegin": [
+    {
+      "args": "(const char* name,bool* p_open,ImGuiWindowFlags flags)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "p_open",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(const char* name,bool* p_open=((void*)0),ImGuiWindowFlags flags=0)",
+      "call_args": "(name,p_open,flags)",
+      "cimguiname": "igBegin",
+      "defaults": {
+        "flags": "0",
+        "p_open": "NULL"
+      },
+      "funcname": "Begin",
+      "location": "imgui:374",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBegin",
+      "ret": "bool",
+      "signature": "(const char*,bool*,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginBoxSelect": [
+    {
+      "args": "(const ImRect scope_rect,ImGuiWindow* window,ImGuiID box_select_id,ImGuiMultiSelectFlags ms_flags)",
+      "argsT": [
+        {
+          "name": "scope_rect",
+          "type": "const ImRect"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "box_select_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "ms_flags",
+          "type": "ImGuiMultiSelectFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& scope_rect,ImGuiWindow* window,ImGuiID box_select_id,ImGuiMultiSelectFlags ms_flags)",
+      "call_args": "(scope_rect,window,box_select_id,ms_flags)",
+      "cimguiname": "igBeginBoxSelect",
+      "defaults": {},
+      "funcname": "BeginBoxSelect",
+      "location": "imgui_internal:3561",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginBoxSelect",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiWindow*,ImGuiID,ImGuiMultiSelectFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginChild": [
+    {
+      "args": "(const char* str_id,const ImVec2 size,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "child_flags",
+          "type": "ImGuiChildFlags"
+        },
+        {
+          "name": "window_flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,const ImVec2& size=ImVec2(0,0),ImGuiChildFlags child_flags=0,ImGuiWindowFlags window_flags=0)",
+      "call_args": "(str_id,size,child_flags,window_flags)",
+      "cimguiname": "igBeginChild",
+      "defaults": {
+        "child_flags": "0",
+        "size": "ImVec2(0,0)",
+        "window_flags": "0"
+      },
+      "funcname": "BeginChild",
+      "location": "imgui:395",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginChild_Str",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiID id,const ImVec2 size,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "child_flags",
+          "type": "ImGuiChildFlags"
+        },
+        {
+          "name": "window_flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,const ImVec2& size=ImVec2(0,0),ImGuiChildFlags child_flags=0,ImGuiWindowFlags window_flags=0)",
+      "call_args": "(id,size,child_flags,window_flags)",
+      "cimguiname": "igBeginChild",
+      "defaults": {
+        "child_flags": "0",
+        "size": "ImVec2(0,0)",
+        "window_flags": "0"
+      },
+      "funcname": "BeginChild",
+      "location": "imgui:396",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginChild_ID",
+      "ret": "bool",
+      "signature": "(ImGuiID,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginChildEx": [
+    {
+      "args": "(const char* name,ImGuiID id,const ImVec2 size_arg,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "size_arg",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "child_flags",
+          "type": "ImGuiChildFlags"
+        },
+        {
+          "name": "window_flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(const char* name,ImGuiID id,const ImVec2& size_arg,ImGuiChildFlags child_flags,ImGuiWindowFlags window_flags)",
+      "call_args": "(name,id,size_arg,child_flags,window_flags)",
+      "cimguiname": "igBeginChildEx",
+      "defaults": {},
+      "funcname": "BeginChildEx",
+      "location": "imgui_internal:3338",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginChildEx",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiID,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginColumns": [
+    {
+      "args": "(const char* str_id,int count,ImGuiOldColumnFlags flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiOldColumnFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,int count,ImGuiOldColumnFlags flags=0)",
+      "call_args": "(str_id,count,flags)",
+      "cimguiname": "igBeginColumns",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginColumns",
+      "location": "imgui_internal:3574",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginColumns",
+      "ret": "void",
+      "signature": "(const char*,int,ImGuiOldColumnFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginCombo": [
+    {
+      "args": "(const char* label,const char* preview_value,ImGuiComboFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "preview_value",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiComboFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* preview_value,ImGuiComboFlags flags=0)",
+      "call_args": "(label,preview_value,flags)",
+      "cimguiname": "igBeginCombo",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginCombo",
+      "location": "imgui:582",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginCombo",
+      "ret": "bool",
+      "signature": "(const char*,const char*,ImGuiComboFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginComboPopup": [
+    {
+      "args": "(ImGuiID popup_id,const ImRect bb,ImGuiComboFlags flags)",
+      "argsT": [
+        {
+          "name": "popup_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiComboFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID popup_id,const ImRect& bb,ImGuiComboFlags flags)",
+      "call_args": "(popup_id,bb,flags)",
+      "cimguiname": "igBeginComboPopup",
+      "defaults": {},
+      "funcname": "BeginComboPopup",
+      "location": "imgui_internal:3364",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginComboPopup",
+      "ret": "bool",
+      "signature": "(ImGuiID,const ImRect,ImGuiComboFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginComboPreview": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginComboPreview",
+      "defaults": {},
+      "funcname": "BeginComboPreview",
+      "location": "imgui_internal:3365",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginComboPreview",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginDisabled": [
+    {
+      "args": "(bool disabled)",
+      "argsT": [
+        {
+          "name": "disabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool disabled=true)",
+      "call_args": "(disabled)",
+      "cimguiname": "igBeginDisabled",
+      "defaults": {
+        "disabled": "true"
+      },
+      "funcname": "BeginDisabled",
+      "location": "imgui:924",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDisabled",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "igBeginDisabledOverrideReenable": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginDisabledOverrideReenable",
+      "defaults": {},
+      "funcname": "BeginDisabledOverrideReenable",
+      "location": "imgui_internal:3328",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDisabledOverrideReenable",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginDockableDragDropSource": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igBeginDockableDragDropSource",
+      "defaults": {},
+      "funcname": "BeginDockableDragDropSource",
+      "location": "imgui_internal:3505",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDockableDragDropSource",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igBeginDockableDragDropTarget": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igBeginDockableDragDropTarget",
+      "defaults": {},
+      "funcname": "BeginDockableDragDropTarget",
+      "location": "imgui_internal:3506",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDockableDragDropTarget",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igBeginDocked": [
+    {
+      "args": "(ImGuiWindow* window,bool* p_open)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,bool* p_open)",
+      "call_args": "(window,p_open)",
+      "cimguiname": "igBeginDocked",
+      "defaults": {},
+      "funcname": "BeginDocked",
+      "location": "imgui_internal:3504",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDocked",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,bool*)",
+      "stname": ""
+    }
+  ],
+  "igBeginDragDropSource": [
+    {
+      "args": "(ImGuiDragDropFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiDragDropFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiDragDropFlags flags=0)",
+      "call_args": "(flags)",
+      "cimguiname": "igBeginDragDropSource",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginDragDropSource",
+      "location": "imgui:911",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDragDropSource",
+      "ret": "bool",
+      "signature": "(ImGuiDragDropFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginDragDropTarget": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginDragDropTarget",
+      "defaults": {},
+      "funcname": "BeginDragDropTarget",
+      "location": "imgui:914",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDragDropTarget",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginDragDropTargetCustom": [
+    {
+      "args": "(const ImRect bb,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id)",
+      "call_args": "(bb,id)",
+      "cimguiname": "igBeginDragDropTargetCustom",
+      "defaults": {},
+      "funcname": "BeginDragDropTargetCustom",
+      "location": "imgui_internal:3547",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginDragDropTargetCustom",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igBeginErrorTooltip": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginErrorTooltip",
+      "defaults": {},
+      "funcname": "BeginErrorTooltip",
+      "location": "imgui_internal:3777",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginErrorTooltip",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginGroup": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginGroup",
+      "defaults": {},
+      "funcname": "BeginGroup",
+      "location": "imgui:509",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginGroup",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginItemTooltip": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginItemTooltip",
+      "defaults": {},
+      "funcname": "BeginItemTooltip",
+      "location": "imgui:753",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginItemTooltip",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginListBox": [
+    {
+      "args": "(const char* label,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size=ImVec2(0,0))",
+      "call_args": "(label,size)",
+      "cimguiname": "igBeginListBox",
+      "defaults": {
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "BeginListBox",
+      "location": "imgui:707",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginListBox",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igBeginMainMenuBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginMainMenuBar",
+      "defaults": {},
+      "funcname": "BeginMainMenuBar",
+      "location": "imgui:733",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginMainMenuBar",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginMenu": [
+    {
+      "args": "(const char* label,bool enabled)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool enabled=true)",
+      "call_args": "(label,enabled)",
+      "cimguiname": "igBeginMenu",
+      "defaults": {
+        "enabled": "true"
+      },
+      "funcname": "BeginMenu",
+      "location": "imgui:735",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginMenu",
+      "ret": "bool",
+      "signature": "(const char*,bool)",
+      "stname": ""
+    }
+  ],
+  "igBeginMenuBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginMenuBar",
+      "defaults": {},
+      "funcname": "BeginMenuBar",
+      "location": "imgui:731",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginMenuBar",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginMenuEx": [
+    {
+      "args": "(const char* label,const char* icon,bool enabled)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "icon",
+          "type": "const char*"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* icon,bool enabled=true)",
+      "call_args": "(label,icon,enabled)",
+      "cimguiname": "igBeginMenuEx",
+      "defaults": {
+        "enabled": "true"
+      },
+      "funcname": "BeginMenuEx",
+      "location": "imgui_internal:3360",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginMenuEx",
+      "ret": "bool",
+      "signature": "(const char*,const char*,bool)",
+      "stname": ""
+    }
+  ],
+  "igBeginMultiSelect": [
+    {
+      "args": "(ImGuiMultiSelectFlags flags,int selection_size,int items_count)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiMultiSelectFlags"
+        },
+        {
+          "name": "selection_size",
+          "type": "int"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiMultiSelectFlags flags,int selection_size=-1,int items_count=-1)",
+      "call_args": "(flags,selection_size,items_count)",
+      "cimguiname": "igBeginMultiSelect",
+      "defaults": {
+        "items_count": "-1",
+        "selection_size": "-1"
+      },
+      "funcname": "BeginMultiSelect",
+      "location": "imgui:696",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginMultiSelect",
+      "ret": "ImGuiMultiSelectIO*",
+      "signature": "(ImGuiMultiSelectFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "igBeginPopup": [
+    {
+      "args": "(const char* str_id,ImGuiWindowFlags flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiWindowFlags flags=0)",
+      "call_args": "(str_id,flags)",
+      "cimguiname": "igBeginPopup",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginPopup",
+      "location": "imgui:767",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginPopup",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginPopupContextItem": [
+    {
+      "args": "(const char* str_id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id=((void*)0),ImGuiPopupFlags popup_flags=1)",
+      "call_args": "(str_id,popup_flags)",
+      "cimguiname": "igBeginPopupContextItem",
+      "defaults": {
+        "popup_flags": "1",
+        "str_id": "NULL"
+      },
+      "funcname": "BeginPopupContextItem",
+      "location": "imgui:789",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginPopupContextItem",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginPopupContextVoid": [
+    {
+      "args": "(const char* str_id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id=((void*)0),ImGuiPopupFlags popup_flags=1)",
+      "call_args": "(str_id,popup_flags)",
+      "cimguiname": "igBeginPopupContextVoid",
+      "defaults": {
+        "popup_flags": "1",
+        "str_id": "NULL"
+      },
+      "funcname": "BeginPopupContextVoid",
+      "location": "imgui:791",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginPopupContextVoid",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginPopupContextWindow": [
+    {
+      "args": "(const char* str_id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id=((void*)0),ImGuiPopupFlags popup_flags=1)",
+      "call_args": "(str_id,popup_flags)",
+      "cimguiname": "igBeginPopupContextWindow",
+      "defaults": {
+        "popup_flags": "1",
+        "str_id": "NULL"
+      },
+      "funcname": "BeginPopupContextWindow",
+      "location": "imgui:790",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginPopupContextWindow",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginPopupEx": [
+    {
+      "args": "(ImGuiID id,ImGuiWindowFlags extra_window_flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "extra_window_flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiWindowFlags extra_window_flags)",
+      "call_args": "(id,extra_window_flags)",
+      "cimguiname": "igBeginPopupEx",
+      "defaults": {},
+      "funcname": "BeginPopupEx",
+      "location": "imgui_internal:3341",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginPopupEx",
+      "ret": "bool",
+      "signature": "(ImGuiID,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginPopupModal": [
+    {
+      "args": "(const char* name,bool* p_open,ImGuiWindowFlags flags)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "p_open",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(const char* name,bool* p_open=((void*)0),ImGuiWindowFlags flags=0)",
+      "call_args": "(name,p_open,flags)",
+      "cimguiname": "igBeginPopupModal",
+      "defaults": {
+        "flags": "0",
+        "p_open": "NULL"
+      },
+      "funcname": "BeginPopupModal",
+      "location": "imgui:768",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginPopupModal",
+      "ret": "bool",
+      "signature": "(const char*,bool*,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginTabBar": [
+    {
+      "args": "(const char* str_id,ImGuiTabBarFlags flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabBarFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiTabBarFlags flags=0)",
+      "call_args": "(str_id,flags)",
+      "cimguiname": "igBeginTabBar",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginTabBar",
+      "location": "imgui:869",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTabBar",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiTabBarFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginTabBarEx": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,const ImRect bb,ImGuiTabBarFlags flags)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabBarFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,const ImRect& bb,ImGuiTabBarFlags flags)",
+      "call_args": "(tab_bar,bb,flags)",
+      "cimguiname": "igBeginTabBarEx",
+      "defaults": {},
+      "funcname": "BeginTabBarEx",
+      "location": "imgui_internal:3642",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTabBarEx",
+      "ret": "bool",
+      "signature": "(ImGuiTabBar*,const ImRect,ImGuiTabBarFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginTabItem": [
+    {
+      "args": "(const char* label,bool* p_open,ImGuiTabItemFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "p_open",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabItemFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool* p_open=((void*)0),ImGuiTabItemFlags flags=0)",
+      "call_args": "(label,p_open,flags)",
+      "cimguiname": "igBeginTabItem",
+      "defaults": {
+        "flags": "0",
+        "p_open": "NULL"
+      },
+      "funcname": "BeginTabItem",
+      "location": "imgui:871",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTabItem",
+      "ret": "bool",
+      "signature": "(const char*,bool*,ImGuiTabItemFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginTable": [
+    {
+      "args": "(const char* str_id,int columns,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "columns",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTableFlags"
+        },
+        {
+          "name": "outer_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "inner_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,int columns,ImGuiTableFlags flags=0,const ImVec2& outer_size=ImVec2(0.0f,0.0f),float inner_width=0.0f)",
+      "call_args": "(str_id,columns,flags,outer_size,inner_width)",
+      "cimguiname": "igBeginTable",
+      "defaults": {
+        "flags": "0",
+        "inner_width": "0.0f",
+        "outer_size": "ImVec2(0.0f,0.0f)"
+      },
+      "funcname": "BeginTable",
+      "location": "imgui:820",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTable",
+      "ret": "bool",
+      "signature": "(const char*,int,ImGuiTableFlags,const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igBeginTableEx": [
+    {
+      "args": "(const char* name,ImGuiID id,int columns_count,ImGuiTableFlags flags,const ImVec2 outer_size,float inner_width)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "columns_count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTableFlags"
+        },
+        {
+          "name": "outer_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "inner_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const char* name,ImGuiID id,int columns_count,ImGuiTableFlags flags=0,const ImVec2& outer_size=ImVec2(0,0),float inner_width=0.0f)",
+      "call_args": "(name,id,columns_count,flags,outer_size,inner_width)",
+      "cimguiname": "igBeginTableEx",
+      "defaults": {
+        "flags": "0",
+        "inner_width": "0.0f",
+        "outer_size": "ImVec2(0,0)"
+      },
+      "funcname": "BeginTableEx",
+      "location": "imgui_internal:3598",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTableEx",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiID,int,ImGuiTableFlags,const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igBeginTooltip": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginTooltip",
+      "defaults": {},
+      "funcname": "BeginTooltip",
+      "location": "imgui:744",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTooltip",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginTooltipEx": [
+    {
+      "args": "(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags)",
+      "argsT": [
+        {
+          "name": "tooltip_flags",
+          "type": "ImGuiTooltipFlags"
+        },
+        {
+          "name": "extra_window_flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags)",
+      "call_args": "(tooltip_flags,extra_window_flags)",
+      "cimguiname": "igBeginTooltipEx",
+      "defaults": {},
+      "funcname": "BeginTooltipEx",
+      "location": "imgui_internal:3355",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTooltipEx",
+      "ret": "bool",
+      "signature": "(ImGuiTooltipFlags,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBeginTooltipHidden": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBeginTooltipHidden",
+      "defaults": {},
+      "funcname": "BeginTooltipHidden",
+      "location": "imgui_internal:3356",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginTooltipHidden",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBeginViewportSideBar": [
+    {
+      "args": "(const char* name,ImGuiViewport* viewport,ImGuiDir dir,float size,ImGuiWindowFlags window_flags)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "viewport",
+          "type": "ImGuiViewport*"
+        },
+        {
+          "name": "dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "window_flags",
+          "type": "ImGuiWindowFlags"
+        }
+      ],
+      "argsoriginal": "(const char* name,ImGuiViewport* viewport,ImGuiDir dir,float size,ImGuiWindowFlags window_flags)",
+      "call_args": "(name,viewport,dir,size,window_flags)",
+      "cimguiname": "igBeginViewportSideBar",
+      "defaults": {},
+      "funcname": "BeginViewportSideBar",
+      "location": "imgui_internal:3359",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBeginViewportSideBar",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiViewport*,ImGuiDir,float,ImGuiWindowFlags)",
+      "stname": ""
+    }
+  ],
+  "igBringWindowToDisplayBack": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igBringWindowToDisplayBack",
+      "defaults": {},
+      "funcname": "BringWindowToDisplayBack",
+      "location": "imgui_internal:3224",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBringWindowToDisplayBack",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igBringWindowToDisplayBehind": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiWindow* above_window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "above_window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiWindow* above_window)",
+      "call_args": "(window,above_window)",
+      "cimguiname": "igBringWindowToDisplayBehind",
+      "defaults": {},
+      "funcname": "BringWindowToDisplayBehind",
+      "location": "imgui_internal:3225",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBringWindowToDisplayBehind",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igBringWindowToDisplayFront": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igBringWindowToDisplayFront",
+      "defaults": {},
+      "funcname": "BringWindowToDisplayFront",
+      "location": "imgui_internal:3223",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBringWindowToDisplayFront",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igBringWindowToFocusFront": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igBringWindowToFocusFront",
+      "defaults": {},
+      "funcname": "BringWindowToFocusFront",
+      "location": "imgui_internal:3222",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBringWindowToFocusFront",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igBullet": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igBullet",
+      "defaults": {},
+      "funcname": "Bullet",
+      "location": "imgui:567",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBullet",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igBulletText": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igBulletText",
+      "defaults": {},
+      "funcname": "BulletText",
+      "isvararg": "...)",
+      "location": "imgui:550",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBulletText",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igBulletTextV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igBulletTextV",
+      "defaults": {},
+      "funcname": "BulletTextV",
+      "location": "imgui:551",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igBulletTextV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igButton": [
+    {
+      "args": "(const char* label,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size=ImVec2(0,0))",
+      "call_args": "(label,size)",
+      "cimguiname": "igButton",
+      "defaults": {
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "Button",
+      "location": "imgui:557",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igButton",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igButtonBehavior": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,bool* out_hovered,bool* out_held,ImGuiButtonFlags flags)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "out_hovered",
+          "type": "bool*"
+        },
+        {
+          "name": "out_held",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiButtonFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,bool* out_hovered,bool* out_held,ImGuiButtonFlags flags=0)",
+      "call_args": "(bb,id,out_hovered,out_held,flags)",
+      "cimguiname": "igButtonBehavior",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ButtonBehavior",
+      "location": "imgui_internal:3712",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igButtonBehavior",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,bool*,bool*,ImGuiButtonFlags)",
+      "stname": ""
+    }
+  ],
+  "igButtonEx": [
+    {
+      "args": "(const char* label,const ImVec2 size_arg,ImGuiButtonFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size_arg",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiButtonFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size_arg=ImVec2(0,0),ImGuiButtonFlags flags=0)",
+      "call_args": "(label,size_arg,flags)",
+      "cimguiname": "igButtonEx",
+      "defaults": {
+        "flags": "0",
+        "size_arg": "ImVec2(0,0)"
+      },
+      "funcname": "ButtonEx",
+      "location": "imgui_internal:3693",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igButtonEx",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,ImGuiButtonFlags)",
+      "stname": ""
+    }
+  ],
+  "igCalcItemSize": [
+    {
+      "args": "(ImVec2 *pOut,ImVec2 size,float default_w,float default_h)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "size",
+          "type": "ImVec2"
+        },
+        {
+          "name": "default_w",
+          "type": "float"
+        },
+        {
+          "name": "default_h",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImVec2 size,float default_w,float default_h)",
+      "call_args": "(size,default_w,default_h)",
+      "cimguiname": "igCalcItemSize",
+      "defaults": {},
+      "funcname": "CalcItemSize",
+      "location": "imgui_internal:3321",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igCalcItemSize",
+      "ret": "void",
+      "signature": "(ImVec2,float,float)",
+      "stname": ""
+    }
+  ],
+  "igCalcItemWidth": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igCalcItemWidth",
+      "defaults": {},
+      "funcname": "CalcItemWidth",
+      "location": "imgui:466",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCalcItemWidth",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igCalcRoundingFlagsForRectInRect": [
+    {
+      "args": "(const ImRect r_in,const ImRect r_outer,float threshold)",
+      "argsT": [
+        {
+          "name": "r_in",
+          "type": "const ImRect"
+        },
+        {
+          "name": "r_outer",
+          "type": "const ImRect"
+        },
+        {
+          "name": "threshold",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImRect& r_in,const ImRect& r_outer,float threshold)",
+      "call_args": "(r_in,r_outer,threshold)",
+      "cimguiname": "igCalcRoundingFlagsForRectInRect",
+      "defaults": {},
+      "funcname": "CalcRoundingFlagsForRectInRect",
+      "location": "imgui_internal:3689",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCalcRoundingFlagsForRectInRect",
+      "ret": "ImDrawFlags",
+      "signature": "(const ImRect,const ImRect,float)",
+      "stname": ""
+    }
+  ],
+  "igCalcTextSize": [
+    {
+      "args": "(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "hide_text_after_double_hash",
+          "type": "bool"
+        },
+        {
+          "name": "wrap_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const char* text,const char* text_end=((void*)0),bool hide_text_after_double_hash=false,float wrap_width=-1.0f)",
+      "call_args": "(text,text_end,hide_text_after_double_hash,wrap_width)",
+      "cimguiname": "igCalcTextSize",
+      "defaults": {
+        "hide_text_after_double_hash": "false",
+        "text_end": "NULL",
+        "wrap_width": "-1.0f"
+      },
+      "funcname": "CalcTextSize",
+      "location": "imgui:984",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igCalcTextSize",
+      "ret": "void",
+      "signature": "(const char*,const char*,bool,float)",
+      "stname": ""
+    }
+  ],
+  "igCalcTypematicRepeatAmount": [
+    {
+      "args": "(float t0,float t1,float repeat_delay,float repeat_rate)",
+      "argsT": [
+        {
+          "name": "t0",
+          "type": "float"
+        },
+        {
+          "name": "t1",
+          "type": "float"
+        },
+        {
+          "name": "repeat_delay",
+          "type": "float"
+        },
+        {
+          "name": "repeat_rate",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float t0,float t1,float repeat_delay,float repeat_rate)",
+      "call_args": "(t0,t1,repeat_delay,repeat_rate)",
+      "cimguiname": "igCalcTypematicRepeatAmount",
+      "defaults": {},
+      "funcname": "CalcTypematicRepeatAmount",
+      "location": "imgui_internal:3420",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCalcTypematicRepeatAmount",
+      "ret": "int",
+      "signature": "(float,float,float,float)",
+      "stname": ""
+    }
+  ],
+  "igCalcWindowNextAutoFitSize": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igCalcWindowNextAutoFitSize",
+      "defaults": {},
+      "funcname": "CalcWindowNextAutoFitSize",
+      "location": "imgui_internal:3203",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igCalcWindowNextAutoFitSize",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igCalcWrapWidthForPos": [
+    {
+      "args": "(const ImVec2 pos,float wrap_pos_x)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "wrap_pos_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,float wrap_pos_x)",
+      "call_args": "(pos,wrap_pos_x)",
+      "cimguiname": "igCalcWrapWidthForPos",
+      "defaults": {},
+      "funcname": "CalcWrapWidthForPos",
+      "location": "imgui_internal:3322",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCalcWrapWidthForPos",
+      "ret": "float",
+      "signature": "(const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igCallContextHooks": [
+    {
+      "args": "(ImGuiContext* context,ImGuiContextHookType type)",
+      "argsT": [
+        {
+          "name": "context",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "type",
+          "type": "ImGuiContextHookType"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* context,ImGuiContextHookType type)",
+      "call_args": "(context,type)",
+      "cimguiname": "igCallContextHooks",
+      "defaults": {},
+      "funcname": "CallContextHooks",
+      "location": "imgui_internal:3254",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCallContextHooks",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiContextHookType)",
+      "stname": ""
+    }
+  ],
+  "igCheckbox": [
+    {
+      "args": "(const char* label,bool* v)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool* v)",
+      "call_args": "(label,v)",
+      "cimguiname": "igCheckbox",
+      "defaults": {},
+      "funcname": "Checkbox",
+      "location": "imgui:561",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCheckbox",
+      "ret": "bool",
+      "signature": "(const char*,bool*)",
+      "stname": ""
+    }
+  ],
+  "igCheckboxFlags": [
+    {
+      "args": "(const char* label,int* flags,int flags_value)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "int*"
+        },
+        {
+          "name": "flags_value",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* flags,int flags_value)",
+      "call_args": "(label,flags,flags_value)",
+      "cimguiname": "igCheckboxFlags",
+      "defaults": {},
+      "funcname": "CheckboxFlags",
+      "location": "imgui:562",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCheckboxFlags_IntPtr",
+      "ret": "bool",
+      "signature": "(const char*,int*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,unsigned int* flags,unsigned int flags_value)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "unsigned int*"
+        },
+        {
+          "name": "flags_value",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(const char* label,unsigned int* flags,unsigned int flags_value)",
+      "call_args": "(label,flags,flags_value)",
+      "cimguiname": "igCheckboxFlags",
+      "defaults": {},
+      "funcname": "CheckboxFlags",
+      "location": "imgui:563",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCheckboxFlags_UintPtr",
+      "ret": "bool",
+      "signature": "(const char*,unsigned int*,unsigned int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,ImS64* flags,ImS64 flags_value)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImS64*"
+        },
+        {
+          "name": "flags_value",
+          "type": "ImS64"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImS64* flags,ImS64 flags_value)",
+      "call_args": "(label,flags,flags_value)",
+      "cimguiname": "igCheckboxFlags",
+      "defaults": {},
+      "funcname": "CheckboxFlags",
+      "location": "imgui_internal:3698",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCheckboxFlags_S64Ptr",
+      "ret": "bool",
+      "signature": "(const char*,ImS64*,ImS64)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,ImU64* flags,ImU64 flags_value)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImU64*"
+        },
+        {
+          "name": "flags_value",
+          "type": "ImU64"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImU64* flags,ImU64 flags_value)",
+      "call_args": "(label,flags,flags_value)",
+      "cimguiname": "igCheckboxFlags",
+      "defaults": {},
+      "funcname": "CheckboxFlags",
+      "location": "imgui_internal:3699",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCheckboxFlags_U64Ptr",
+      "ret": "bool",
+      "signature": "(const char*,ImU64*,ImU64)",
+      "stname": ""
+    }
+  ],
+  "igClearActiveID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igClearActiveID",
+      "defaults": {},
+      "funcname": "ClearActiveID",
+      "location": "imgui_internal:3304",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClearActiveID",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igClearDragDrop": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igClearDragDrop",
+      "defaults": {},
+      "funcname": "ClearDragDrop",
+      "location": "imgui_internal:3548",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClearDragDrop",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igClearIniSettings": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igClearIniSettings",
+      "defaults": {},
+      "funcname": "ClearIniSettings",
+      "location": "imgui_internal:3268",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClearIniSettings",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igClearWindowSettings": [
+    {
+      "args": "(const char* name)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "igClearWindowSettings",
+      "defaults": {},
+      "funcname": "ClearWindowSettings",
+      "location": "imgui_internal:3277",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClearWindowSettings",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igCloseButton": [
+    {
+      "args": "(ImGuiID id,const ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,const ImVec2& pos)",
+      "call_args": "(id,pos)",
+      "cimguiname": "igCloseButton",
+      "defaults": {},
+      "funcname": "CloseButton",
+      "location": "imgui_internal:3702",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCloseButton",
+      "ret": "bool",
+      "signature": "(ImGuiID,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igCloseCurrentPopup": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igCloseCurrentPopup",
+      "defaults": {},
+      "funcname": "CloseCurrentPopup",
+      "location": "imgui:782",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCloseCurrentPopup",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igClosePopupToLevel": [
+    {
+      "args": "(int remaining,bool restore_focus_to_window_under_popup)",
+      "argsT": [
+        {
+          "name": "remaining",
+          "type": "int"
+        },
+        {
+          "name": "restore_focus_to_window_under_popup",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(int remaining,bool restore_focus_to_window_under_popup)",
+      "call_args": "(remaining,restore_focus_to_window_under_popup)",
+      "cimguiname": "igClosePopupToLevel",
+      "defaults": {},
+      "funcname": "ClosePopupToLevel",
+      "location": "imgui_internal:3343",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClosePopupToLevel",
+      "ret": "void",
+      "signature": "(int,bool)",
+      "stname": ""
+    }
+  ],
+  "igClosePopupsExceptModals": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igClosePopupsExceptModals",
+      "defaults": {},
+      "funcname": "ClosePopupsExceptModals",
+      "location": "imgui_internal:3345",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClosePopupsExceptModals",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igClosePopupsOverWindow": [
+    {
+      "args": "(ImGuiWindow* ref_window,bool restore_focus_to_window_under_popup)",
+      "argsT": [
+        {
+          "name": "ref_window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "restore_focus_to_window_under_popup",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* ref_window,bool restore_focus_to_window_under_popup)",
+      "call_args": "(ref_window,restore_focus_to_window_under_popup)",
+      "cimguiname": "igClosePopupsOverWindow",
+      "defaults": {},
+      "funcname": "ClosePopupsOverWindow",
+      "location": "imgui_internal:3344",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igClosePopupsOverWindow",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "igCollapseButton": [
+    {
+      "args": "(ImGuiID id,const ImVec2 pos,ImGuiDockNode* dock_node)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "dock_node",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,const ImVec2& pos,ImGuiDockNode* dock_node)",
+      "call_args": "(id,pos,dock_node)",
+      "cimguiname": "igCollapseButton",
+      "defaults": {},
+      "funcname": "CollapseButton",
+      "location": "imgui_internal:3703",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCollapseButton",
+      "ret": "bool",
+      "signature": "(ImGuiID,const ImVec2,ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igCollapsingHeader": [
+    {
+      "args": "(const char* label,ImGuiTreeNodeFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiTreeNodeFlags flags=0)",
+      "call_args": "(label,flags)",
+      "cimguiname": "igCollapsingHeader",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "CollapsingHeader",
+      "location": "imgui:678",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCollapsingHeader_TreeNodeFlags",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiTreeNodeFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,bool* p_visible,ImGuiTreeNodeFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "p_visible",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool* p_visible,ImGuiTreeNodeFlags flags=0)",
+      "call_args": "(label,p_visible,flags)",
+      "cimguiname": "igCollapsingHeader",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "CollapsingHeader",
+      "location": "imgui:679",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCollapsingHeader_BoolPtr",
+      "ret": "bool",
+      "signature": "(const char*,bool*,ImGuiTreeNodeFlags)",
+      "stname": ""
+    }
+  ],
+  "igColorButton": [
+    {
+      "args": "(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "desc_id",
+          "type": "const char*"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* desc_id,const ImVec4& col,ImGuiColorEditFlags flags=0,const ImVec2& size=ImVec2(0,0))",
+      "call_args": "(desc_id,col,flags,size)",
+      "cimguiname": "igColorButton",
+      "defaults": {
+        "flags": "0",
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "ColorButton",
+      "location": "imgui:659",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorButton",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec4,ImGuiColorEditFlags,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igColorConvertFloat4ToU32": [
+    {
+      "args": "(const ImVec4 in)",
+      "argsT": [
+        {
+          "name": "in",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& in)",
+      "call_args": "(in)",
+      "cimguiname": "igColorConvertFloat4ToU32",
+      "defaults": {},
+      "funcname": "ColorConvertFloat4ToU32",
+      "location": "imgui:988",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorConvertFloat4ToU32",
+      "ret": "ImU32",
+      "signature": "(const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "igColorConvertHSVtoRGB": [
+    {
+      "args": "(float h,float s,float v,float* out_r,float* out_g,float* out_b)",
+      "argsT": [
+        {
+          "name": "h",
+          "type": "float"
+        },
+        {
+          "name": "s",
+          "type": "float"
+        },
+        {
+          "name": "v",
+          "type": "float"
+        },
+        {
+          "name": "out_r",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "out_g",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "out_b",
+          "reftoptr": true,
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(float h,float s,float v,float& out_r,float& out_g,float& out_b)",
+      "call_args": "(h,s,v,*out_r,*out_g,*out_b)",
+      "cimguiname": "igColorConvertHSVtoRGB",
+      "defaults": {},
+      "funcname": "ColorConvertHSVtoRGB",
+      "location": "imgui:990",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorConvertHSVtoRGB",
+      "ret": "void",
+      "signature": "(float,float,float,float*,float*,float*)",
+      "stname": ""
+    }
+  ],
+  "igColorConvertRGBtoHSV": [
+    {
+      "args": "(float r,float g,float b,float* out_h,float* out_s,float* out_v)",
+      "argsT": [
+        {
+          "name": "r",
+          "type": "float"
+        },
+        {
+          "name": "g",
+          "type": "float"
+        },
+        {
+          "name": "b",
+          "type": "float"
+        },
+        {
+          "name": "out_h",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "out_s",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "out_v",
+          "reftoptr": true,
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(float r,float g,float b,float& out_h,float& out_s,float& out_v)",
+      "call_args": "(r,g,b,*out_h,*out_s,*out_v)",
+      "cimguiname": "igColorConvertRGBtoHSV",
+      "defaults": {},
+      "funcname": "ColorConvertRGBtoHSV",
+      "location": "imgui:989",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorConvertRGBtoHSV",
+      "ret": "void",
+      "signature": "(float,float,float,float*,float*,float*)",
+      "stname": ""
+    }
+  ],
+  "igColorConvertU32ToFloat4": [
+    {
+      "args": "(ImVec4 *pOut,ImU32 in)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "in",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 in)",
+      "call_args": "(in)",
+      "cimguiname": "igColorConvertU32ToFloat4",
+      "defaults": {},
+      "funcname": "ColorConvertU32ToFloat4",
+      "location": "imgui:987",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igColorConvertU32ToFloat4",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "igColorEdit3": [
+    {
+      "args": "(const char* label,float col[3],ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "col",
+          "type": "float[3]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float col[3],ImGuiColorEditFlags flags=0)",
+      "call_args": "(label,col,flags)",
+      "cimguiname": "igColorEdit3",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ColorEdit3",
+      "location": "imgui:655",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorEdit3",
+      "ret": "bool",
+      "signature": "(const char*,float[3],ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igColorEdit4": [
+    {
+      "args": "(const char* label,float col[4],ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "col",
+          "type": "float[4]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float col[4],ImGuiColorEditFlags flags=0)",
+      "call_args": "(label,col,flags)",
+      "cimguiname": "igColorEdit4",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ColorEdit4",
+      "location": "imgui:656",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorEdit4",
+      "ret": "bool",
+      "signature": "(const char*,float[4],ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igColorEditOptionsPopup": [
+    {
+      "args": "(const float* col,ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const float*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(const float* col,ImGuiColorEditFlags flags)",
+      "call_args": "(col,flags)",
+      "cimguiname": "igColorEditOptionsPopup",
+      "defaults": {},
+      "funcname": "ColorEditOptionsPopup",
+      "location": "imgui_internal:3754",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorEditOptionsPopup",
+      "ret": "void",
+      "signature": "(const float*,ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igColorPicker3": [
+    {
+      "args": "(const char* label,float col[3],ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "col",
+          "type": "float[3]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float col[3],ImGuiColorEditFlags flags=0)",
+      "call_args": "(label,col,flags)",
+      "cimguiname": "igColorPicker3",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ColorPicker3",
+      "location": "imgui:657",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorPicker3",
+      "ret": "bool",
+      "signature": "(const char*,float[3],ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igColorPicker4": [
+    {
+      "args": "(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "col",
+          "type": "float[4]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        },
+        {
+          "name": "ref_col",
+          "type": "const float*"
+        }
+      ],
+      "argsoriginal": "(const char* label,float col[4],ImGuiColorEditFlags flags=0,const float* ref_col=((void*)0))",
+      "call_args": "(label,col,flags,ref_col)",
+      "cimguiname": "igColorPicker4",
+      "defaults": {
+        "flags": "0",
+        "ref_col": "NULL"
+      },
+      "funcname": "ColorPicker4",
+      "location": "imgui:658",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorPicker4",
+      "ret": "bool",
+      "signature": "(const char*,float[4],ImGuiColorEditFlags,const float*)",
+      "stname": ""
+    }
+  ],
+  "igColorPickerOptionsPopup": [
+    {
+      "args": "(const float* ref_col,ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "ref_col",
+          "type": "const float*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(const float* ref_col,ImGuiColorEditFlags flags)",
+      "call_args": "(ref_col,flags)",
+      "cimguiname": "igColorPickerOptionsPopup",
+      "defaults": {},
+      "funcname": "ColorPickerOptionsPopup",
+      "location": "imgui_internal:3755",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorPickerOptionsPopup",
+      "ret": "void",
+      "signature": "(const float*,ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igColorTooltip": [
+    {
+      "args": "(const char* text,const float* col,ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "col",
+          "type": "const float*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(const char* text,const float* col,ImGuiColorEditFlags flags)",
+      "call_args": "(text,col,flags)",
+      "cimguiname": "igColorTooltip",
+      "defaults": {},
+      "funcname": "ColorTooltip",
+      "location": "imgui_internal:3753",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColorTooltip",
+      "ret": "void",
+      "signature": "(const char*,const float*,ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igColumns": [
+    {
+      "args": "(int count,const char* id,bool borders)",
+      "argsT": [
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "id",
+          "type": "const char*"
+        },
+        {
+          "name": "borders",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(int count=1,const char* id=((void*)0),bool borders=true)",
+      "call_args": "(count,id,borders)",
+      "cimguiname": "igColumns",
+      "defaults": {
+        "borders": "true",
+        "count": "1",
+        "id": "NULL"
+      },
+      "funcname": "Columns",
+      "location": "imgui:858",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igColumns",
+      "ret": "void",
+      "signature": "(int,const char*,bool)",
+      "stname": ""
+    }
+  ],
+  "igCombo": [
+    {
+      "args": "(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "current_item",
+          "type": "int*"
+        },
+        {
+          "name": "items",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "popup_max_height_in_items",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items=-1)",
+      "call_args": "(label,current_item,items,items_count,popup_max_height_in_items)",
+      "cimguiname": "igCombo",
+      "defaults": {
+        "popup_max_height_in_items": "-1"
+      },
+      "funcname": "Combo",
+      "location": "imgui:584",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCombo_Str_arr",
+      "ret": "bool",
+      "signature": "(const char*,int*,const char* const[],int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "current_item",
+          "type": "int*"
+        },
+        {
+          "name": "items_separated_by_zeros",
+          "type": "const char*"
+        },
+        {
+          "name": "popup_max_height_in_items",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items=-1)",
+      "call_args": "(label,current_item,items_separated_by_zeros,popup_max_height_in_items)",
+      "cimguiname": "igCombo",
+      "defaults": {
+        "popup_max_height_in_items": "-1"
+      },
+      "funcname": "Combo",
+      "location": "imgui:585",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCombo_Str",
+      "ret": "bool",
+      "signature": "(const char*,int*,const char*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,int* current_item,const char*(*getter)(void* user_data,int idx),void* user_data,int items_count,int popup_max_height_in_items)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "current_item",
+          "type": "int*"
+        },
+        {
+          "name": "getter",
+          "ret": "const char*",
+          "signature": "(void* user_data,int idx)",
+          "type": "const char*(*)(void* user_data,int idx)"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "popup_max_height_in_items",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* current_item,const char*(*getter)(void* user_data,int idx),void* user_data,int items_count,int popup_max_height_in_items=-1)",
+      "call_args": "(label,current_item,getter,user_data,items_count,popup_max_height_in_items)",
+      "cimguiname": "igCombo",
+      "defaults": {
+        "popup_max_height_in_items": "-1"
+      },
+      "funcname": "Combo",
+      "location": "imgui:586",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCombo_FnStrPtr",
+      "ret": "bool",
+      "signature": "(const char*,int*,const char*(*)(void*,int),void*,int,int)",
+      "stname": ""
+    }
+  ],
+  "igConvertSingleModFlagToKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igConvertSingleModFlagToKey",
+      "defaults": {},
+      "funcname": "ConvertSingleModFlagToKey",
+      "location": "imgui_internal:3404",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igConvertSingleModFlagToKey",
+      "ret": "ImGuiKey",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igCreateContext": [
+    {
+      "args": "(ImFontAtlas* shared_font_atlas)",
+      "argsT": [
+        {
+          "name": "shared_font_atlas",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* shared_font_atlas=((void*)0))",
+      "call_args": "(shared_font_atlas)",
+      "cimguiname": "igCreateContext",
+      "defaults": {
+        "shared_font_atlas": "NULL"
+      },
+      "funcname": "CreateContext",
+      "location": "imgui:331",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCreateContext",
+      "ret": "ImGuiContext*",
+      "signature": "(ImFontAtlas*)",
+      "stname": ""
+    }
+  ],
+  "igCreateNewWindowSettings": [
+    {
+      "args": "(const char* name)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "igCreateNewWindowSettings",
+      "defaults": {},
+      "funcname": "CreateNewWindowSettings",
+      "location": "imgui_internal:3274",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igCreateNewWindowSettings",
+      "ret": "ImGuiWindowSettings*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeApplyFromText": [
+    {
+      "args": "(const char* buf,ImGuiDataType data_type,void* p_data,const char* format,void* p_data_when_empty)",
+      "argsT": [
+        {
+          "name": "buf",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "p_data_when_empty",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(const char* buf,ImGuiDataType data_type,void* p_data,const char* format,void* p_data_when_empty=((void*)0))",
+      "call_args": "(buf,data_type,p_data,format,p_data_when_empty)",
+      "cimguiname": "igDataTypeApplyFromText",
+      "defaults": {
+        "p_data_when_empty": "NULL"
+      },
+      "funcname": "DataTypeApplyFromText",
+      "location": "imgui_internal:3738",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeApplyFromText",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,const char*,void*)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeApplyOp": [
+    {
+      "args": "(ImGuiDataType data_type,int op,void* output,const void* arg_1,const void* arg_2)",
+      "argsT": [
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "op",
+          "type": "int"
+        },
+        {
+          "name": "output",
+          "type": "void*"
+        },
+        {
+          "name": "arg_1",
+          "type": "const void*"
+        },
+        {
+          "name": "arg_2",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDataType data_type,int op,void* output,const void* arg_1,const void* arg_2)",
+      "call_args": "(data_type,op,output,arg_1,arg_2)",
+      "cimguiname": "igDataTypeApplyOp",
+      "defaults": {},
+      "funcname": "DataTypeApplyOp",
+      "location": "imgui_internal:3737",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeApplyOp",
+      "ret": "void",
+      "signature": "(ImGuiDataType,int,void*,const void*,const void*)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeClamp": [
+    {
+      "args": "(ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max)",
+      "argsT": [
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max)",
+      "call_args": "(data_type,p_data,p_min,p_max)",
+      "cimguiname": "igDataTypeClamp",
+      "defaults": {},
+      "funcname": "DataTypeClamp",
+      "location": "imgui_internal:3740",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeClamp",
+      "ret": "bool",
+      "signature": "(ImGuiDataType,void*,const void*,const void*)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeCompare": [
+    {
+      "args": "(ImGuiDataType data_type,const void* arg_1,const void* arg_2)",
+      "argsT": [
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "arg_1",
+          "type": "const void*"
+        },
+        {
+          "name": "arg_2",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDataType data_type,const void* arg_1,const void* arg_2)",
+      "call_args": "(data_type,arg_1,arg_2)",
+      "cimguiname": "igDataTypeCompare",
+      "defaults": {},
+      "funcname": "DataTypeCompare",
+      "location": "imgui_internal:3739",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeCompare",
+      "ret": "int",
+      "signature": "(ImGuiDataType,const void*,const void*)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeFormatString": [
+    {
+      "args": "(char* buf,int buf_size,ImGuiDataType data_type,const void* p_data,const char* format)",
+      "argsT": [
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "int"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(char* buf,int buf_size,ImGuiDataType data_type,const void* p_data,const char* format)",
+      "call_args": "(buf,buf_size,data_type,p_data,format)",
+      "cimguiname": "igDataTypeFormatString",
+      "defaults": {},
+      "funcname": "DataTypeFormatString",
+      "location": "imgui_internal:3736",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeFormatString",
+      "ret": "int",
+      "signature": "(char*,int,ImGuiDataType,const void*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeGetInfo": [
+    {
+      "args": "(ImGuiDataType data_type)",
+      "argsT": [
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        }
+      ],
+      "argsoriginal": "(ImGuiDataType data_type)",
+      "call_args": "(data_type)",
+      "cimguiname": "igDataTypeGetInfo",
+      "defaults": {},
+      "funcname": "DataTypeGetInfo",
+      "location": "imgui_internal:3735",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeGetInfo",
+      "ret": "const ImGuiDataTypeInfo*",
+      "signature": "(ImGuiDataType)",
+      "stname": ""
+    }
+  ],
+  "igDataTypeIsZero": [
+    {
+      "args": "(ImGuiDataType data_type,const void* p_data)",
+      "argsT": [
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDataType data_type,const void* p_data)",
+      "call_args": "(data_type,p_data)",
+      "cimguiname": "igDataTypeIsZero",
+      "defaults": {},
+      "funcname": "DataTypeIsZero",
+      "location": "imgui_internal:3741",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDataTypeIsZero",
+      "ret": "bool",
+      "signature": "(ImGuiDataType,const void*)",
+      "stname": ""
+    }
+  ],
+  "igDebugAllocHook": [
+    {
+      "args": "(ImGuiDebugAllocInfo* info,int frame_count,void* ptr,size_t size)",
+      "argsT": [
+        {
+          "name": "info",
+          "type": "ImGuiDebugAllocInfo*"
+        },
+        {
+          "name": "frame_count",
+          "type": "int"
+        },
+        {
+          "name": "ptr",
+          "type": "void*"
+        },
+        {
+          "name": "size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(ImGuiDebugAllocInfo* info,int frame_count,void* ptr,size_t size)",
+      "call_args": "(info,frame_count,ptr,size)",
+      "cimguiname": "igDebugAllocHook",
+      "defaults": {},
+      "funcname": "DebugAllocHook",
+      "location": "imgui_internal:3781",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugAllocHook",
+      "ret": "void",
+      "signature": "(ImGuiDebugAllocInfo*,int,void*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igDebugBreakButton": [
+    {
+      "args": "(const char* label,const char* description_of_location)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "description_of_location",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* description_of_location)",
+      "call_args": "(label,description_of_location)",
+      "cimguiname": "igDebugBreakButton",
+      "defaults": {},
+      "funcname": "DebugBreakButton",
+      "location": "imgui_internal:3790",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugBreakButton",
+      "ret": "bool",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugBreakButtonTooltip": [
+    {
+      "args": "(bool keyboard_only,const char* description_of_location)",
+      "argsT": [
+        {
+          "name": "keyboard_only",
+          "type": "bool"
+        },
+        {
+          "name": "description_of_location",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(bool keyboard_only,const char* description_of_location)",
+      "call_args": "(keyboard_only,description_of_location)",
+      "cimguiname": "igDebugBreakButtonTooltip",
+      "defaults": {},
+      "funcname": "DebugBreakButtonTooltip",
+      "location": "imgui_internal:3791",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugBreakButtonTooltip",
+      "ret": "void",
+      "signature": "(bool,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugBreakClearData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igDebugBreakClearData",
+      "defaults": {},
+      "funcname": "DebugBreakClearData",
+      "location": "imgui_internal:3789",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugBreakClearData",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igDebugCheckVersionAndDataLayout": [
+    {
+      "args": "(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)",
+      "argsT": [
+        {
+          "name": "version_str",
+          "type": "const char*"
+        },
+        {
+          "name": "sz_io",
+          "type": "size_t"
+        },
+        {
+          "name": "sz_style",
+          "type": "size_t"
+        },
+        {
+          "name": "sz_vec2",
+          "type": "size_t"
+        },
+        {
+          "name": "sz_vec4",
+          "type": "size_t"
+        },
+        {
+          "name": "sz_drawvert",
+          "type": "size_t"
+        },
+        {
+          "name": "sz_drawidx",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx)",
+      "call_args": "(version_str,sz_io,sz_style,sz_vec2,sz_vec4,sz_drawvert,sz_drawidx)",
+      "cimguiname": "igDebugCheckVersionAndDataLayout",
+      "defaults": {},
+      "funcname": "DebugCheckVersionAndDataLayout",
+      "location": "imgui:1070",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugCheckVersionAndDataLayout",
+      "ret": "bool",
+      "signature": "(const char*,size_t,size_t,size_t,size_t,size_t,size_t)",
+      "stname": ""
+    }
+  ],
+  "igDebugDrawCursorPos": [
+    {
+      "args": "(ImU32 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col=(((ImU32)(255)<<24)|((ImU32)(0)<<16)|((ImU32)(0)<<8)|((ImU32)(255)<<0)))",
+      "call_args": "(col)",
+      "cimguiname": "igDebugDrawCursorPos",
+      "defaults": {
+        "col": "4278190335"
+      },
+      "funcname": "DebugDrawCursorPos",
+      "location": "imgui_internal:3782",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugDrawCursorPos",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "igDebugDrawItemRect": [
+    {
+      "args": "(ImU32 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col=(((ImU32)(255)<<24)|((ImU32)(0)<<16)|((ImU32)(0)<<8)|((ImU32)(255)<<0)))",
+      "call_args": "(col)",
+      "cimguiname": "igDebugDrawItemRect",
+      "defaults": {
+        "col": "4278190335"
+      },
+      "funcname": "DebugDrawItemRect",
+      "location": "imgui_internal:3784",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugDrawItemRect",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "igDebugDrawLineExtents": [
+    {
+      "args": "(ImU32 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col=(((ImU32)(255)<<24)|((ImU32)(0)<<16)|((ImU32)(0)<<8)|((ImU32)(255)<<0)))",
+      "call_args": "(col)",
+      "cimguiname": "igDebugDrawLineExtents",
+      "defaults": {
+        "col": "4278190335"
+      },
+      "funcname": "DebugDrawLineExtents",
+      "location": "imgui_internal:3783",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugDrawLineExtents",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "igDebugFlashStyleColor": [
+    {
+      "args": "(ImGuiCol idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiCol"
+        }
+      ],
+      "argsoriginal": "(ImGuiCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "igDebugFlashStyleColor",
+      "defaults": {},
+      "funcname": "DebugFlashStyleColor",
+      "location": "imgui:1068",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugFlashStyleColor",
+      "ret": "void",
+      "signature": "(ImGuiCol)",
+      "stname": ""
+    }
+  ],
+  "igDebugHookIdInfo": [
+    {
+      "args": "(ImGuiID id,ImGuiDataType data_type,const void* data_id,const void* data_id_end)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "data_id",
+          "type": "const void*"
+        },
+        {
+          "name": "data_id_end",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiDataType data_type,const void* data_id,const void* data_id_end)",
+      "call_args": "(id,data_type,data_id,data_id_end)",
+      "cimguiname": "igDebugHookIdInfo",
+      "defaults": {},
+      "funcname": "DebugHookIdInfo",
+      "location": "imgui_internal:3793",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugHookIdInfo",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiDataType,const void*,const void*)",
+      "stname": ""
+    }
+  ],
+  "igDebugLocateItem": [
+    {
+      "args": "(ImGuiID target_id)",
+      "argsT": [
+        {
+          "name": "target_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID target_id)",
+      "call_args": "(target_id)",
+      "cimguiname": "igDebugLocateItem",
+      "defaults": {},
+      "funcname": "DebugLocateItem",
+      "location": "imgui_internal:3786",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugLocateItem",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDebugLocateItemOnHover": [
+    {
+      "args": "(ImGuiID target_id)",
+      "argsT": [
+        {
+          "name": "target_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID target_id)",
+      "call_args": "(target_id)",
+      "cimguiname": "igDebugLocateItemOnHover",
+      "defaults": {},
+      "funcname": "DebugLocateItemOnHover",
+      "location": "imgui_internal:3787",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugLocateItemOnHover",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDebugLocateItemResolveWithLastItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igDebugLocateItemResolveWithLastItem",
+      "defaults": {},
+      "funcname": "DebugLocateItemResolveWithLastItem",
+      "location": "imgui_internal:3788",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugLocateItemResolveWithLastItem",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igDebugLog": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igDebugLog",
+      "defaults": {},
+      "funcname": "DebugLog",
+      "isvararg": "...)",
+      "location": "imgui:1072",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugLog",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igDebugLogV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igDebugLogV",
+      "defaults": {},
+      "funcname": "DebugLogV",
+      "location": "imgui:1073",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugLogV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeColumns": [
+    {
+      "args": "(ImGuiOldColumns* columns)",
+      "argsT": [
+        {
+          "name": "columns",
+          "type": "ImGuiOldColumns*"
+        }
+      ],
+      "argsoriginal": "(ImGuiOldColumns* columns)",
+      "call_args": "(columns)",
+      "cimguiname": "igDebugNodeColumns",
+      "defaults": {},
+      "funcname": "DebugNodeColumns",
+      "location": "imgui_internal:3794",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeColumns",
+      "ret": "void",
+      "signature": "(ImGuiOldColumns*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeDockNode": [
+    {
+      "args": "(ImGuiDockNode* node,const char* label)",
+      "argsT": [
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDockNode* node,const char* label)",
+      "call_args": "(node,label)",
+      "cimguiname": "igDebugNodeDockNode",
+      "defaults": {},
+      "funcname": "DebugNodeDockNode",
+      "location": "imgui_internal:3795",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeDockNode",
+      "ret": "void",
+      "signature": "(ImGuiDockNode*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeDrawCmdShowMeshAndBoundingBox": [
+    {
+      "args": "(ImDrawList* out_draw_list,const ImDrawList* draw_list,const ImDrawCmd* draw_cmd,bool show_mesh,bool show_aabb)",
+      "argsT": [
+        {
+          "name": "out_draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "draw_list",
+          "type": "const ImDrawList*"
+        },
+        {
+          "name": "draw_cmd",
+          "type": "const ImDrawCmd*"
+        },
+        {
+          "name": "show_mesh",
+          "type": "bool"
+        },
+        {
+          "name": "show_aabb",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* out_draw_list,const ImDrawList* draw_list,const ImDrawCmd* draw_cmd,bool show_mesh,bool show_aabb)",
+      "call_args": "(out_draw_list,draw_list,draw_cmd,show_mesh,show_aabb)",
+      "cimguiname": "igDebugNodeDrawCmdShowMeshAndBoundingBox",
+      "defaults": {},
+      "funcname": "DebugNodeDrawCmdShowMeshAndBoundingBox",
+      "location": "imgui_internal:3797",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeDrawCmdShowMeshAndBoundingBox",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImDrawList*,const ImDrawCmd*,bool,bool)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeDrawList": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiViewportP* viewport,const ImDrawList* draw_list,const char* label)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        },
+        {
+          "name": "draw_list",
+          "type": "const ImDrawList*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiViewportP* viewport,const ImDrawList* draw_list,const char* label)",
+      "call_args": "(window,viewport,draw_list,label)",
+      "cimguiname": "igDebugNodeDrawList",
+      "defaults": {},
+      "funcname": "DebugNodeDrawList",
+      "location": "imgui_internal:3796",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeDrawList",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiViewportP*,const ImDrawList*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeFont": [
+    {
+      "args": "(ImFont* font)",
+      "argsT": [
+        {
+          "name": "font",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "(ImFont* font)",
+      "call_args": "(font)",
+      "cimguiname": "igDebugNodeFont",
+      "defaults": {},
+      "funcname": "DebugNodeFont",
+      "location": "imgui_internal:3798",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeFont",
+      "ret": "void",
+      "signature": "(ImFont*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeFontGlyph": [
+    {
+      "args": "(ImFont* font,const ImFontGlyph* glyph)",
+      "argsT": [
+        {
+          "name": "font",
+          "type": "ImFont*"
+        },
+        {
+          "name": "glyph",
+          "type": "const ImFontGlyph*"
+        }
+      ],
+      "argsoriginal": "(ImFont* font,const ImFontGlyph* glyph)",
+      "call_args": "(font,glyph)",
+      "cimguiname": "igDebugNodeFontGlyph",
+      "defaults": {},
+      "funcname": "DebugNodeFontGlyph",
+      "location": "imgui_internal:3799",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeFontGlyph",
+      "ret": "void",
+      "signature": "(ImFont*,const ImFontGlyph*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeInputTextState": [
+    {
+      "args": "(ImGuiInputTextState* state)",
+      "argsT": [
+        {
+          "name": "state",
+          "type": "ImGuiInputTextState*"
+        }
+      ],
+      "argsoriginal": "(ImGuiInputTextState* state)",
+      "call_args": "(state)",
+      "cimguiname": "igDebugNodeInputTextState",
+      "defaults": {},
+      "funcname": "DebugNodeInputTextState",
+      "location": "imgui_internal:3804",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeInputTextState",
+      "ret": "void",
+      "signature": "(ImGuiInputTextState*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeMultiSelectState": [
+    {
+      "args": "(ImGuiMultiSelectState* state)",
+      "argsT": [
+        {
+          "name": "state",
+          "type": "ImGuiMultiSelectState*"
+        }
+      ],
+      "argsoriginal": "(ImGuiMultiSelectState* state)",
+      "call_args": "(state)",
+      "cimguiname": "igDebugNodeMultiSelectState",
+      "defaults": {},
+      "funcname": "DebugNodeMultiSelectState",
+      "location": "imgui_internal:3806",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeMultiSelectState",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectState*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodePlatformMonitor": [
+    {
+      "args": "(ImGuiPlatformMonitor* monitor,const char* label,int idx)",
+      "argsT": [
+        {
+          "name": "monitor",
+          "type": "ImGuiPlatformMonitor*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiPlatformMonitor* monitor,const char* label,int idx)",
+      "call_args": "(monitor,label,idx)",
+      "cimguiname": "igDebugNodePlatformMonitor",
+      "defaults": {},
+      "funcname": "DebugNodePlatformMonitor",
+      "location": "imgui_internal:3812",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodePlatformMonitor",
+      "ret": "void",
+      "signature": "(ImGuiPlatformMonitor*,const char*,int)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeStorage": [
+    {
+      "args": "(ImGuiStorage* storage,const char* label)",
+      "argsT": [
+        {
+          "name": "storage",
+          "type": "ImGuiStorage*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiStorage* storage,const char* label)",
+      "call_args": "(storage,label)",
+      "cimguiname": "igDebugNodeStorage",
+      "defaults": {},
+      "funcname": "DebugNodeStorage",
+      "location": "imgui_internal:3800",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeStorage",
+      "ret": "void",
+      "signature": "(ImGuiStorage*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeTabBar": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,const char* label)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,const char* label)",
+      "call_args": "(tab_bar,label)",
+      "cimguiname": "igDebugNodeTabBar",
+      "defaults": {},
+      "funcname": "DebugNodeTabBar",
+      "location": "imgui_internal:3801",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeTabBar",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeTable": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igDebugNodeTable",
+      "defaults": {},
+      "funcname": "DebugNodeTable",
+      "location": "imgui_internal:3802",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeTable",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeTableSettings": [
+    {
+      "args": "(ImGuiTableSettings* settings)",
+      "argsT": [
+        {
+          "name": "settings",
+          "type": "ImGuiTableSettings*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTableSettings* settings)",
+      "call_args": "(settings)",
+      "cimguiname": "igDebugNodeTableSettings",
+      "defaults": {},
+      "funcname": "DebugNodeTableSettings",
+      "location": "imgui_internal:3803",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeTableSettings",
+      "ret": "void",
+      "signature": "(ImGuiTableSettings*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeTypingSelectState": [
+    {
+      "args": "(ImGuiTypingSelectState* state)",
+      "argsT": [
+        {
+          "name": "state",
+          "type": "ImGuiTypingSelectState*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTypingSelectState* state)",
+      "call_args": "(state)",
+      "cimguiname": "igDebugNodeTypingSelectState",
+      "defaults": {},
+      "funcname": "DebugNodeTypingSelectState",
+      "location": "imgui_internal:3805",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeTypingSelectState",
+      "ret": "void",
+      "signature": "(ImGuiTypingSelectState*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeViewport": [
+    {
+      "args": "(ImGuiViewportP* viewport)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewportP* viewport)",
+      "call_args": "(viewport)",
+      "cimguiname": "igDebugNodeViewport",
+      "defaults": {},
+      "funcname": "DebugNodeViewport",
+      "location": "imgui_internal:3811",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeViewport",
+      "ret": "void",
+      "signature": "(ImGuiViewportP*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeWindow": [
+    {
+      "args": "(ImGuiWindow* window,const char* label)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const char* label)",
+      "call_args": "(window,label)",
+      "cimguiname": "igDebugNodeWindow",
+      "defaults": {},
+      "funcname": "DebugNodeWindow",
+      "location": "imgui_internal:3807",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeWindow",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeWindowSettings": [
+    {
+      "args": "(ImGuiWindowSettings* settings)",
+      "argsT": [
+        {
+          "name": "settings",
+          "type": "ImGuiWindowSettings*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindowSettings* settings)",
+      "call_args": "(settings)",
+      "cimguiname": "igDebugNodeWindowSettings",
+      "defaults": {},
+      "funcname": "DebugNodeWindowSettings",
+      "location": "imgui_internal:3808",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeWindowSettings",
+      "ret": "void",
+      "signature": "(ImGuiWindowSettings*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeWindowsList": [
+    {
+      "args": "(ImVector_ImGuiWindowPtr* windows,const char* label)",
+      "argsT": [
+        {
+          "name": "windows",
+          "type": "ImVector_ImGuiWindowPtr*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImGuiWindow*>* windows,const char* label)",
+      "call_args": "(windows,label)",
+      "cimguiname": "igDebugNodeWindowsList",
+      "defaults": {},
+      "funcname": "DebugNodeWindowsList",
+      "location": "imgui_internal:3809",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeWindowsList",
+      "ret": "void",
+      "signature": "(ImVector_ImGuiWindowPtr*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugNodeWindowsListByBeginStackParent": [
+    {
+      "args": "(ImGuiWindow** windows,int windows_size,ImGuiWindow* parent_in_begin_stack)",
+      "argsT": [
+        {
+          "name": "windows",
+          "type": "ImGuiWindow**"
+        },
+        {
+          "name": "windows_size",
+          "type": "int"
+        },
+        {
+          "name": "parent_in_begin_stack",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow** windows,int windows_size,ImGuiWindow* parent_in_begin_stack)",
+      "call_args": "(windows,windows_size,parent_in_begin_stack)",
+      "cimguiname": "igDebugNodeWindowsListByBeginStackParent",
+      "defaults": {},
+      "funcname": "DebugNodeWindowsListByBeginStackParent",
+      "location": "imgui_internal:3810",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugNodeWindowsListByBeginStackParent",
+      "ret": "void",
+      "signature": "(ImGuiWindow**,int,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igDebugRenderKeyboardPreview": [
+    {
+      "args": "(ImDrawList* draw_list)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list)",
+      "call_args": "(draw_list)",
+      "cimguiname": "igDebugRenderKeyboardPreview",
+      "defaults": {},
+      "funcname": "DebugRenderKeyboardPreview",
+      "location": "imgui_internal:3813",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugRenderKeyboardPreview",
+      "ret": "void",
+      "signature": "(ImDrawList*)",
+      "stname": ""
+    }
+  ],
+  "igDebugRenderViewportThumbnail": [
+    {
+      "args": "(ImDrawList* draw_list,ImGuiViewportP* viewport,const ImRect bb)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        },
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImGuiViewportP* viewport,const ImRect& bb)",
+      "call_args": "(draw_list,viewport,bb)",
+      "cimguiname": "igDebugRenderViewportThumbnail",
+      "defaults": {},
+      "funcname": "DebugRenderViewportThumbnail",
+      "location": "imgui_internal:3814",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugRenderViewportThumbnail",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImGuiViewportP*,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igDebugStartItemPicker": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igDebugStartItemPicker",
+      "defaults": {},
+      "funcname": "DebugStartItemPicker",
+      "location": "imgui:1069",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugStartItemPicker",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igDebugTextEncoding": [
+    {
+      "args": "(const char* text)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text)",
+      "call_args": "(text)",
+      "cimguiname": "igDebugTextEncoding",
+      "defaults": {},
+      "funcname": "DebugTextEncoding",
+      "location": "imgui:1067",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugTextEncoding",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igDebugTextUnformattedWithLocateItem": [
+    {
+      "args": "(const char* line_begin,const char* line_end)",
+      "argsT": [
+        {
+          "name": "line_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "line_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* line_begin,const char* line_end)",
+      "call_args": "(line_begin,line_end)",
+      "cimguiname": "igDebugTextUnformattedWithLocateItem",
+      "defaults": {},
+      "funcname": "DebugTextUnformattedWithLocateItem",
+      "location": "imgui_internal:3785",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDebugTextUnformattedWithLocateItem",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDestroyContext": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx=((void*)0))",
+      "call_args": "(ctx)",
+      "cimguiname": "igDestroyContext",
+      "defaults": {
+        "ctx": "NULL"
+      },
+      "funcname": "DestroyContext",
+      "location": "imgui:332",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDestroyContext",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDestroyPlatformWindow": [
+    {
+      "args": "(ImGuiViewportP* viewport)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewportP* viewport)",
+      "call_args": "(viewport)",
+      "cimguiname": "igDestroyPlatformWindow",
+      "defaults": {},
+      "funcname": "DestroyPlatformWindow",
+      "location": "imgui_internal:3259",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDestroyPlatformWindow",
+      "ret": "void",
+      "signature": "(ImGuiViewportP*)",
+      "stname": ""
+    }
+  ],
+  "igDestroyPlatformWindows": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igDestroyPlatformWindows",
+      "defaults": {},
+      "funcname": "DestroyPlatformWindows",
+      "location": "imgui:1090",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDestroyPlatformWindows",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderAddNode": [
+    {
+      "args": "(ImGuiID node_id,ImGuiDockNodeFlags flags)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDockNodeFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id=0,ImGuiDockNodeFlags flags=0)",
+      "call_args": "(node_id,flags)",
+      "cimguiname": "igDockBuilderAddNode",
+      "defaults": {
+        "flags": "0",
+        "node_id": "0"
+      },
+      "funcname": "DockBuilderAddNode",
+      "location": "imgui_internal:3521",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderAddNode",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiID,ImGuiDockNodeFlags)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderCopyDockSpace": [
+    {
+      "args": "(ImGuiID src_dockspace_id,ImGuiID dst_dockspace_id,ImVector_const_charPtr* in_window_remap_pairs)",
+      "argsT": [
+        {
+          "name": "src_dockspace_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "dst_dockspace_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "in_window_remap_pairs",
+          "type": "ImVector_const_charPtr*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID src_dockspace_id,ImGuiID dst_dockspace_id,ImVector<const char*>* in_window_remap_pairs)",
+      "call_args": "(src_dockspace_id,dst_dockspace_id,in_window_remap_pairs)",
+      "cimguiname": "igDockBuilderCopyDockSpace",
+      "defaults": {},
+      "funcname": "DockBuilderCopyDockSpace",
+      "location": "imgui_internal:3528",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderCopyDockSpace",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiID,ImVector_const_charPtr*)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderCopyNode": [
+    {
+      "args": "(ImGuiID src_node_id,ImGuiID dst_node_id,ImVector_ImGuiID* out_node_remap_pairs)",
+      "argsT": [
+        {
+          "name": "src_node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "dst_node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "out_node_remap_pairs",
+          "type": "ImVector_ImGuiID*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID src_node_id,ImGuiID dst_node_id,ImVector<ImGuiID>* out_node_remap_pairs)",
+      "call_args": "(src_node_id,dst_node_id,out_node_remap_pairs)",
+      "cimguiname": "igDockBuilderCopyNode",
+      "defaults": {},
+      "funcname": "DockBuilderCopyNode",
+      "location": "imgui_internal:3529",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderCopyNode",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiID,ImVector_ImGuiID*)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderCopyWindowSettings": [
+    {
+      "args": "(const char* src_name,const char* dst_name)",
+      "argsT": [
+        {
+          "name": "src_name",
+          "type": "const char*"
+        },
+        {
+          "name": "dst_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* src_name,const char* dst_name)",
+      "call_args": "(src_name,dst_name)",
+      "cimguiname": "igDockBuilderCopyWindowSettings",
+      "defaults": {},
+      "funcname": "DockBuilderCopyWindowSettings",
+      "location": "imgui_internal:3530",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderCopyWindowSettings",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderDockWindow": [
+    {
+      "args": "(const char* window_name,ImGuiID node_id)",
+      "argsT": [
+        {
+          "name": "window_name",
+          "type": "const char*"
+        },
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const char* window_name,ImGuiID node_id)",
+      "call_args": "(window_name,node_id)",
+      "cimguiname": "igDockBuilderDockWindow",
+      "defaults": {},
+      "funcname": "DockBuilderDockWindow",
+      "location": "imgui_internal:3518",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderDockWindow",
+      "ret": "void",
+      "signature": "(const char*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderFinish": [
+    {
+      "args": "(ImGuiID node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "igDockBuilderFinish",
+      "defaults": {},
+      "funcname": "DockBuilderFinish",
+      "location": "imgui_internal:3531",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderFinish",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderGetCentralNode": [
+    {
+      "args": "(ImGuiID node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "igDockBuilderGetCentralNode",
+      "defaults": {},
+      "funcname": "DockBuilderGetCentralNode",
+      "location": "imgui_internal:3520",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderGetCentralNode",
+      "ret": "ImGuiDockNode*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderGetNode": [
+    {
+      "args": "(ImGuiID node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "igDockBuilderGetNode",
+      "defaults": {},
+      "funcname": "DockBuilderGetNode",
+      "location": "imgui_internal:3519",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderGetNode",
+      "ret": "ImGuiDockNode*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderRemoveNode": [
+    {
+      "args": "(ImGuiID node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "igDockBuilderRemoveNode",
+      "defaults": {},
+      "funcname": "DockBuilderRemoveNode",
+      "location": "imgui_internal:3522",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderRemoveNode",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderRemoveNodeChildNodes": [
+    {
+      "args": "(ImGuiID node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "igDockBuilderRemoveNodeChildNodes",
+      "defaults": {},
+      "funcname": "DockBuilderRemoveNodeChildNodes",
+      "location": "imgui_internal:3524",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderRemoveNodeChildNodes",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderRemoveNodeDockedWindows": [
+    {
+      "args": "(ImGuiID node_id,bool clear_settings_refs)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "clear_settings_refs",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id,bool clear_settings_refs=true)",
+      "call_args": "(node_id,clear_settings_refs)",
+      "cimguiname": "igDockBuilderRemoveNodeDockedWindows",
+      "defaults": {
+        "clear_settings_refs": "true"
+      },
+      "funcname": "DockBuilderRemoveNodeDockedWindows",
+      "location": "imgui_internal:3523",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderRemoveNodeDockedWindows",
+      "ret": "void",
+      "signature": "(ImGuiID,bool)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderSetNodePos": [
+    {
+      "args": "(ImGuiID node_id,ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id,ImVec2 pos)",
+      "call_args": "(node_id,pos)",
+      "cimguiname": "igDockBuilderSetNodePos",
+      "defaults": {},
+      "funcname": "DockBuilderSetNodePos",
+      "location": "imgui_internal:3525",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderSetNodePos",
+      "ret": "void",
+      "signature": "(ImGuiID,ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderSetNodeSize": [
+    {
+      "args": "(ImGuiID node_id,ImVec2 size)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "size",
+          "type": "ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id,ImVec2 size)",
+      "call_args": "(node_id,size)",
+      "cimguiname": "igDockBuilderSetNodeSize",
+      "defaults": {},
+      "funcname": "DockBuilderSetNodeSize",
+      "location": "imgui_internal:3526",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderSetNodeSize",
+      "ret": "void",
+      "signature": "(ImGuiID,ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igDockBuilderSplitNode": [
+    {
+      "args": "(ImGuiID node_id,ImGuiDir split_dir,float size_ratio_for_node_at_dir,ImGuiID* out_id_at_dir,ImGuiID* out_id_at_opposite_dir)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "split_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "size_ratio_for_node_at_dir",
+          "type": "float"
+        },
+        {
+          "name": "out_id_at_dir",
+          "type": "ImGuiID*"
+        },
+        {
+          "name": "out_id_at_opposite_dir",
+          "type": "ImGuiID*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID node_id,ImGuiDir split_dir,float size_ratio_for_node_at_dir,ImGuiID* out_id_at_dir,ImGuiID* out_id_at_opposite_dir)",
+      "call_args": "(node_id,split_dir,size_ratio_for_node_at_dir,out_id_at_dir,out_id_at_opposite_dir)",
+      "cimguiname": "igDockBuilderSplitNode",
+      "defaults": {},
+      "funcname": "DockBuilderSplitNode",
+      "location": "imgui_internal:3527",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockBuilderSplitNode",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiID,ImGuiDir,float,ImGuiID*,ImGuiID*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextCalcDropPosForDocking": [
+    {
+      "args": "(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload_window,ImGuiDockNode* payload_node,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos)",
+      "argsT": [
+        {
+          "name": "target",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "target_node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "payload_window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "payload_node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "split_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "split_outer",
+          "type": "bool"
+        },
+        {
+          "name": "out_pos",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload_window,ImGuiDockNode* payload_node,ImGuiDir split_dir,bool split_outer,ImVec2* out_pos)",
+      "call_args": "(target,target_node,payload_window,payload_node,split_dir,split_outer,out_pos)",
+      "cimguiname": "igDockContextCalcDropPosForDocking",
+      "defaults": {},
+      "funcname": "DockContextCalcDropPosForDocking",
+      "location": "imgui_internal:3493",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextCalcDropPosForDocking",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*,ImGuiDockNode*,ImGuiWindow*,ImGuiDockNode*,ImGuiDir,bool,ImVec2*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextClearNodes": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiID root_id,bool clear_settings_refs)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "root_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "clear_settings_refs",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiID root_id,bool clear_settings_refs)",
+      "call_args": "(ctx,root_id,clear_settings_refs)",
+      "cimguiname": "igDockContextClearNodes",
+      "defaults": {},
+      "funcname": "DockContextClearNodes",
+      "location": "imgui_internal:3482",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextClearNodes",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiID,bool)",
+      "stname": ""
+    }
+  ],
+  "igDockContextEndFrame": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextEndFrame",
+      "defaults": {},
+      "funcname": "DockContextEndFrame",
+      "location": "imgui_internal:3486",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextEndFrame",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextFindNodeByID": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiID id)",
+      "call_args": "(ctx,id)",
+      "cimguiname": "igDockContextFindNodeByID",
+      "defaults": {},
+      "funcname": "DockContextFindNodeByID",
+      "location": "imgui_internal:3494",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextFindNodeByID",
+      "ret": "ImGuiDockNode*",
+      "signature": "(ImGuiContext*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igDockContextGenNodeID": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextGenNodeID",
+      "defaults": {},
+      "funcname": "DockContextGenNodeID",
+      "location": "imgui_internal:3487",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextGenNodeID",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextInitialize": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextInitialize",
+      "defaults": {},
+      "funcname": "DockContextInitialize",
+      "location": "imgui_internal:3480",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextInitialize",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextNewFrameUpdateDocking": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextNewFrameUpdateDocking",
+      "defaults": {},
+      "funcname": "DockContextNewFrameUpdateDocking",
+      "location": "imgui_internal:3485",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextNewFrameUpdateDocking",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextNewFrameUpdateUndocking": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextNewFrameUpdateUndocking",
+      "defaults": {},
+      "funcname": "DockContextNewFrameUpdateUndocking",
+      "location": "imgui_internal:3484",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextNewFrameUpdateUndocking",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextProcessUndockNode": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiDockNode* node)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiDockNode* node)",
+      "call_args": "(ctx,node)",
+      "cimguiname": "igDockContextProcessUndockNode",
+      "defaults": {},
+      "funcname": "DockContextProcessUndockNode",
+      "location": "imgui_internal:3492",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextProcessUndockNode",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextProcessUndockWindow": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiWindow* window,bool clear_persistent_docking_ref)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "clear_persistent_docking_ref",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiWindow* window,bool clear_persistent_docking_ref=true)",
+      "call_args": "(ctx,window,clear_persistent_docking_ref)",
+      "cimguiname": "igDockContextProcessUndockWindow",
+      "defaults": {
+        "clear_persistent_docking_ref": "true"
+      },
+      "funcname": "DockContextProcessUndockWindow",
+      "location": "imgui_internal:3491",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextProcessUndockWindow",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiWindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "igDockContextQueueDock": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload,ImGuiDir split_dir,float split_ratio,bool split_outer)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "target",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "target_node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "payload",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "split_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "split_ratio",
+          "type": "float"
+        },
+        {
+          "name": "split_outer",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiWindow* target,ImGuiDockNode* target_node,ImGuiWindow* payload,ImGuiDir split_dir,float split_ratio,bool split_outer)",
+      "call_args": "(ctx,target,target_node,payload,split_dir,split_ratio,split_outer)",
+      "cimguiname": "igDockContextQueueDock",
+      "defaults": {},
+      "funcname": "DockContextQueueDock",
+      "location": "imgui_internal:3488",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextQueueDock",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiWindow*,ImGuiDockNode*,ImGuiWindow*,ImGuiDir,float,bool)",
+      "stname": ""
+    }
+  ],
+  "igDockContextQueueUndockNode": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiDockNode* node)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiDockNode* node)",
+      "call_args": "(ctx,node)",
+      "cimguiname": "igDockContextQueueUndockNode",
+      "defaults": {},
+      "funcname": "DockContextQueueUndockNode",
+      "location": "imgui_internal:3490",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextQueueUndockNode",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextQueueUndockWindow": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiWindow* window)",
+      "call_args": "(ctx,window)",
+      "cimguiname": "igDockContextQueueUndockWindow",
+      "defaults": {},
+      "funcname": "DockContextQueueUndockWindow",
+      "location": "imgui_internal:3489",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextQueueUndockWindow",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextRebuildNodes": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextRebuildNodes",
+      "defaults": {},
+      "funcname": "DockContextRebuildNodes",
+      "location": "imgui_internal:3483",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextRebuildNodes",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockContextShutdown": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igDockContextShutdown",
+      "defaults": {},
+      "funcname": "DockContextShutdown",
+      "location": "imgui_internal:3481",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockContextShutdown",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igDockNodeBeginAmendTabBar": [
+    {
+      "args": "(ImGuiDockNode* node)",
+      "argsT": [
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDockNode* node)",
+      "call_args": "(node)",
+      "cimguiname": "igDockNodeBeginAmendTabBar",
+      "defaults": {},
+      "funcname": "DockNodeBeginAmendTabBar",
+      "location": "imgui_internal:3496",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeBeginAmendTabBar",
+      "ret": "bool",
+      "signature": "(ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockNodeEndAmendTabBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igDockNodeEndAmendTabBar",
+      "defaults": {},
+      "funcname": "DockNodeEndAmendTabBar",
+      "location": "imgui_internal:3497",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeEndAmendTabBar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igDockNodeGetDepth": [
+    {
+      "args": "(const ImGuiDockNode* node)",
+      "argsT": [
+        {
+          "name": "node",
+          "type": "const ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(const ImGuiDockNode* node)",
+      "call_args": "(node)",
+      "cimguiname": "igDockNodeGetDepth",
+      "defaults": {},
+      "funcname": "DockNodeGetDepth",
+      "location": "imgui_internal:3500",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeGetDepth",
+      "ret": "int",
+      "signature": "(const ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockNodeGetRootNode": [
+    {
+      "args": "(ImGuiDockNode* node)",
+      "argsT": [
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDockNode* node)",
+      "call_args": "(node)",
+      "cimguiname": "igDockNodeGetRootNode",
+      "defaults": {},
+      "funcname": "DockNodeGetRootNode",
+      "location": "imgui_internal:3498",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeGetRootNode",
+      "ret": "ImGuiDockNode*",
+      "signature": "(ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockNodeGetWindowMenuButtonId": [
+    {
+      "args": "(const ImGuiDockNode* node)",
+      "argsT": [
+        {
+          "name": "node",
+          "type": "const ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(const ImGuiDockNode* node)",
+      "call_args": "(node)",
+      "cimguiname": "igDockNodeGetWindowMenuButtonId",
+      "defaults": {},
+      "funcname": "DockNodeGetWindowMenuButtonId",
+      "location": "imgui_internal:3501",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeGetWindowMenuButtonId",
+      "ret": "ImGuiID",
+      "signature": "(const ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockNodeIsInHierarchyOf": [
+    {
+      "args": "(ImGuiDockNode* node,ImGuiDockNode* parent)",
+      "argsT": [
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "parent",
+          "type": "ImGuiDockNode*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDockNode* node,ImGuiDockNode* parent)",
+      "call_args": "(node,parent)",
+      "cimguiname": "igDockNodeIsInHierarchyOf",
+      "defaults": {},
+      "funcname": "DockNodeIsInHierarchyOf",
+      "location": "imgui_internal:3499",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeIsInHierarchyOf",
+      "ret": "bool",
+      "signature": "(ImGuiDockNode*,ImGuiDockNode*)",
+      "stname": ""
+    }
+  ],
+  "igDockNodeWindowMenuHandler_Default": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiDockNode* node,ImGuiTabBar* tab_bar)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiDockNode* node,ImGuiTabBar* tab_bar)",
+      "call_args": "(ctx,node,tab_bar)",
+      "cimguiname": "igDockNodeWindowMenuHandler_Default",
+      "defaults": {},
+      "funcname": "DockNodeWindowMenuHandler_Default",
+      "location": "imgui_internal:3495",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockNodeWindowMenuHandler_Default",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiDockNode*,ImGuiTabBar*)",
+      "stname": ""
+    }
+  ],
+  "igDockSpace": [
+    {
+      "args": "(ImGuiID dockspace_id,const ImVec2 size,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)",
+      "argsT": [
+        {
+          "name": "dockspace_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDockNodeFlags"
+        },
+        {
+          "name": "window_class",
+          "type": "const ImGuiWindowClass*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID dockspace_id,const ImVec2& size=ImVec2(0,0),ImGuiDockNodeFlags flags=0,const ImGuiWindowClass* window_class=((void*)0))",
+      "call_args": "(dockspace_id,size,flags,window_class)",
+      "cimguiname": "igDockSpace",
+      "defaults": {
+        "flags": "0",
+        "size": "ImVec2(0,0)",
+        "window_class": "NULL"
+      },
+      "funcname": "DockSpace",
+      "location": "imgui:889",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockSpace",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiID,const ImVec2,ImGuiDockNodeFlags,const ImGuiWindowClass*)",
+      "stname": ""
+    }
+  ],
+  "igDockSpaceOverViewport": [
+    {
+      "args": "(ImGuiID dockspace_id,const ImGuiViewport* viewport,ImGuiDockNodeFlags flags,const ImGuiWindowClass* window_class)",
+      "argsT": [
+        {
+          "name": "dockspace_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "viewport",
+          "type": "const ImGuiViewport*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDockNodeFlags"
+        },
+        {
+          "name": "window_class",
+          "type": "const ImGuiWindowClass*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID dockspace_id=0,const ImGuiViewport* viewport=((void*)0),ImGuiDockNodeFlags flags=0,const ImGuiWindowClass* window_class=((void*)0))",
+      "call_args": "(dockspace_id,viewport,flags,window_class)",
+      "cimguiname": "igDockSpaceOverViewport",
+      "defaults": {
+        "dockspace_id": "0",
+        "flags": "0",
+        "viewport": "NULL",
+        "window_class": "NULL"
+      },
+      "funcname": "DockSpaceOverViewport",
+      "location": "imgui:890",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDockSpaceOverViewport",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiID,const ImGuiViewport*,ImGuiDockNodeFlags,const ImGuiWindowClass*)",
+      "stname": ""
+    }
+  ],
+  "igDragBehavior": [
+    {
+      "args": "(ImGuiID id,ImGuiDataType data_type,void* p_v,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_v",
+          "type": "void*"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiDataType data_type,void* p_v,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "call_args": "(id,data_type,p_v,v_speed,p_min,p_max,format,flags)",
+      "cimguiname": "igDragBehavior",
+      "defaults": {},
+      "funcname": "DragBehavior",
+      "location": "imgui_internal:3713",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragBehavior",
+      "ret": "bool",
+      "signature": "(ImGuiID,ImGuiDataType,void*,float,const void*,const void*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragFloat": [
+    {
+      "args": "(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float*"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float* v,float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragFloat",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\"",
+        "v_max": "0.0f",
+        "v_min": "0.0f",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragFloat",
+      "location": "imgui:600",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragFloat",
+      "ret": "bool",
+      "signature": "(const char*,float*,float,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragFloat2": [
+    {
+      "args": "(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[2]"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[2],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragFloat2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\"",
+        "v_max": "0.0f",
+        "v_min": "0.0f",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragFloat2",
+      "location": "imgui:601",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragFloat2",
+      "ret": "bool",
+      "signature": "(const char*,float[2],float,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragFloat3": [
+    {
+      "args": "(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[3]"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[3],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragFloat3",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\"",
+        "v_max": "0.0f",
+        "v_min": "0.0f",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragFloat3",
+      "location": "imgui:602",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragFloat3",
+      "ret": "bool",
+      "signature": "(const char*,float[3],float,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragFloat4": [
+    {
+      "args": "(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[4]"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[4],float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragFloat4",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\"",
+        "v_max": "0.0f",
+        "v_min": "0.0f",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragFloat4",
+      "location": "imgui:603",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragFloat4",
+      "ret": "bool",
+      "signature": "(const char*,float[4],float,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragFloatRange2": [
+    {
+      "args": "(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v_current_min",
+          "type": "float*"
+        },
+        {
+          "name": "v_current_max",
+          "type": "float*"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "format_max",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float* v_current_min,float* v_current_max,float v_speed=1.0f,float v_min=0.0f,float v_max=0.0f,const char* format=\"%.3f\",const char* format_max=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags)",
+      "cimguiname": "igDragFloatRange2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\"",
+        "format_max": "NULL",
+        "v_max": "0.0f",
+        "v_min": "0.0f",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragFloatRange2",
+      "location": "imgui:604",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragFloatRange2",
+      "ret": "bool",
+      "signature": "(const char*,float*,float*,float,float,float,const char*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragInt": [
+    {
+      "args": "(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int*"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* v,float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragInt",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\"",
+        "v_max": "0",
+        "v_min": "0",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragInt",
+      "location": "imgui:605",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragInt",
+      "ret": "bool",
+      "signature": "(const char*,int*,float,int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragInt2": [
+    {
+      "args": "(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[2]"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[2],float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragInt2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\"",
+        "v_max": "0",
+        "v_min": "0",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragInt2",
+      "location": "imgui:606",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragInt2",
+      "ret": "bool",
+      "signature": "(const char*,int[2],float,int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragInt3": [
+    {
+      "args": "(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[3]"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[3],float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragInt3",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\"",
+        "v_max": "0",
+        "v_min": "0",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragInt3",
+      "location": "imgui:607",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragInt3",
+      "ret": "bool",
+      "signature": "(const char*,int[3],float,int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragInt4": [
+    {
+      "args": "(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[4]"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[4],float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_speed,v_min,v_max,format,flags)",
+      "cimguiname": "igDragInt4",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\"",
+        "v_max": "0",
+        "v_min": "0",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragInt4",
+      "location": "imgui:608",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragInt4",
+      "ret": "bool",
+      "signature": "(const char*,int[4],float,int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragIntRange2": [
+    {
+      "args": "(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v_current_min",
+          "type": "int*"
+        },
+        {
+          "name": "v_current_max",
+          "type": "int*"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "format_max",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* v_current_min,int* v_current_max,float v_speed=1.0f,int v_min=0,int v_max=0,const char* format=\"%d\",const char* format_max=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,flags)",
+      "cimguiname": "igDragIntRange2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\"",
+        "format_max": "NULL",
+        "v_max": "0",
+        "v_min": "0",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragIntRange2",
+      "location": "imgui:609",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragIntRange2",
+      "ret": "bool",
+      "signature": "(const char*,int*,int*,float,int,int,const char*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragScalar": [
+    {
+      "args": "(const char* label,ImGuiDataType data_type,void* p_data,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* p_data,float v_speed=1.0f,const void* p_min=((void*)0),const void* p_max=((void*)0),const char* format=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,data_type,p_data,v_speed,p_min,p_max,format,flags)",
+      "cimguiname": "igDragScalar",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL",
+        "p_max": "NULL",
+        "p_min": "NULL",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragScalar",
+      "location": "imgui:610",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragScalar",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,float,const void*,const void*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDragScalarN": [
+    {
+      "args": "(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "components",
+          "type": "int"
+        },
+        {
+          "name": "v_speed",
+          "type": "float"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* p_data,int components,float v_speed=1.0f,const void* p_min=((void*)0),const void* p_max=((void*)0),const char* format=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,data_type,p_data,components,v_speed,p_min,p_max,format,flags)",
+      "cimguiname": "igDragScalarN",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL",
+        "p_max": "NULL",
+        "p_min": "NULL",
+        "v_speed": "1.0f"
+      },
+      "funcname": "DragScalarN",
+      "location": "imgui:611",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDragScalarN",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,int,float,const void*,const void*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igDummy": [
+    {
+      "args": "(const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size)",
+      "call_args": "(size)",
+      "cimguiname": "igDummy",
+      "defaults": {},
+      "funcname": "Dummy",
+      "location": "imgui:506",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igDummy",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igEnd": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEnd",
+      "defaults": {},
+      "funcname": "End",
+      "location": "imgui:375",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEnd",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndBoxSelect": [
+    {
+      "args": "(const ImRect scope_rect,ImGuiMultiSelectFlags ms_flags)",
+      "argsT": [
+        {
+          "name": "scope_rect",
+          "type": "const ImRect"
+        },
+        {
+          "name": "ms_flags",
+          "type": "ImGuiMultiSelectFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& scope_rect,ImGuiMultiSelectFlags ms_flags)",
+      "call_args": "(scope_rect,ms_flags)",
+      "cimguiname": "igEndBoxSelect",
+      "defaults": {},
+      "funcname": "EndBoxSelect",
+      "location": "imgui_internal:3562",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndBoxSelect",
+      "ret": "void",
+      "signature": "(const ImRect,ImGuiMultiSelectFlags)",
+      "stname": ""
+    }
+  ],
+  "igEndChild": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndChild",
+      "defaults": {},
+      "funcname": "EndChild",
+      "location": "imgui:397",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndChild",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndColumns": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndColumns",
+      "defaults": {},
+      "funcname": "EndColumns",
+      "location": "imgui_internal:3575",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndColumns",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndCombo": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndCombo",
+      "defaults": {},
+      "funcname": "EndCombo",
+      "location": "imgui:583",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndCombo",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndComboPreview": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndComboPreview",
+      "defaults": {},
+      "funcname": "EndComboPreview",
+      "location": "imgui_internal:3366",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndComboPreview",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndDisabled": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndDisabled",
+      "defaults": {},
+      "funcname": "EndDisabled",
+      "location": "imgui:925",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndDisabled",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndDisabledOverrideReenable": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndDisabledOverrideReenable",
+      "defaults": {},
+      "funcname": "EndDisabledOverrideReenable",
+      "location": "imgui_internal:3329",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndDisabledOverrideReenable",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndDragDropSource": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndDragDropSource",
+      "defaults": {},
+      "funcname": "EndDragDropSource",
+      "location": "imgui:913",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndDragDropSource",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndDragDropTarget": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndDragDropTarget",
+      "defaults": {},
+      "funcname": "EndDragDropTarget",
+      "location": "imgui:916",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndDragDropTarget",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndErrorTooltip": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndErrorTooltip",
+      "defaults": {},
+      "funcname": "EndErrorTooltip",
+      "location": "imgui_internal:3778",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndErrorTooltip",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndFrame",
+      "defaults": {},
+      "funcname": "EndFrame",
+      "location": "imgui:341",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndGroup": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndGroup",
+      "defaults": {},
+      "funcname": "EndGroup",
+      "location": "imgui:510",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndGroup",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndListBox": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndListBox",
+      "defaults": {},
+      "funcname": "EndListBox",
+      "location": "imgui:708",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndListBox",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndMainMenuBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndMainMenuBar",
+      "defaults": {},
+      "funcname": "EndMainMenuBar",
+      "location": "imgui:734",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndMainMenuBar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndMenu": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndMenu",
+      "defaults": {},
+      "funcname": "EndMenu",
+      "location": "imgui:736",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndMenu",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndMenuBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndMenuBar",
+      "defaults": {},
+      "funcname": "EndMenuBar",
+      "location": "imgui:732",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndMenuBar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndMultiSelect": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndMultiSelect",
+      "defaults": {},
+      "funcname": "EndMultiSelect",
+      "location": "imgui:697",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndMultiSelect",
+      "ret": "ImGuiMultiSelectIO*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndPopup": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndPopup",
+      "defaults": {},
+      "funcname": "EndPopup",
+      "location": "imgui:769",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndPopup",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndTabBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndTabBar",
+      "defaults": {},
+      "funcname": "EndTabBar",
+      "location": "imgui:870",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndTabBar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndTabItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndTabItem",
+      "defaults": {},
+      "funcname": "EndTabItem",
+      "location": "imgui:872",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndTabItem",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndTable": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndTable",
+      "defaults": {},
+      "funcname": "EndTable",
+      "location": "imgui:821",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndTable",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igEndTooltip": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igEndTooltip",
+      "defaults": {},
+      "funcname": "EndTooltip",
+      "location": "imgui:745",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igEndTooltip",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igErrorCheckEndFrameFinalizeErrorTooltip": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igErrorCheckEndFrameFinalizeErrorTooltip",
+      "defaults": {},
+      "funcname": "ErrorCheckEndFrameFinalizeErrorTooltip",
+      "location": "imgui_internal:3776",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igErrorCheckEndFrameFinalizeErrorTooltip",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igErrorCheckUsingSetCursorPosToExtendParentBoundaries": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igErrorCheckUsingSetCursorPosToExtendParentBoundaries",
+      "defaults": {},
+      "funcname": "ErrorCheckUsingSetCursorPosToExtendParentBoundaries",
+      "location": "imgui_internal:3775",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igErrorCheckUsingSetCursorPosToExtendParentBoundaries",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igErrorLog": [
+    {
+      "args": "(const char* msg)",
+      "argsT": [
+        {
+          "name": "msg",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* msg)",
+      "call_args": "(msg)",
+      "cimguiname": "igErrorLog",
+      "defaults": {},
+      "funcname": "ErrorLog",
+      "location": "imgui_internal:3771",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igErrorLog",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igErrorRecoveryStoreState": [
+    {
+      "args": "(ImGuiErrorRecoveryState* state_out)",
+      "argsT": [
+        {
+          "name": "state_out",
+          "type": "ImGuiErrorRecoveryState*"
+        }
+      ],
+      "argsoriginal": "(ImGuiErrorRecoveryState* state_out)",
+      "call_args": "(state_out)",
+      "cimguiname": "igErrorRecoveryStoreState",
+      "defaults": {},
+      "funcname": "ErrorRecoveryStoreState",
+      "location": "imgui_internal:3772",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igErrorRecoveryStoreState",
+      "ret": "void",
+      "signature": "(ImGuiErrorRecoveryState*)",
+      "stname": ""
+    }
+  ],
+  "igErrorRecoveryTryToRecoverState": [
+    {
+      "args": "(const ImGuiErrorRecoveryState* state_in)",
+      "argsT": [
+        {
+          "name": "state_in",
+          "type": "const ImGuiErrorRecoveryState*"
+        }
+      ],
+      "argsoriginal": "(const ImGuiErrorRecoveryState* state_in)",
+      "call_args": "(state_in)",
+      "cimguiname": "igErrorRecoveryTryToRecoverState",
+      "defaults": {},
+      "funcname": "ErrorRecoveryTryToRecoverState",
+      "location": "imgui_internal:3773",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igErrorRecoveryTryToRecoverState",
+      "ret": "void",
+      "signature": "(const ImGuiErrorRecoveryState*)",
+      "stname": ""
+    }
+  ],
+  "igErrorRecoveryTryToRecoverWindowState": [
+    {
+      "args": "(const ImGuiErrorRecoveryState* state_in)",
+      "argsT": [
+        {
+          "name": "state_in",
+          "type": "const ImGuiErrorRecoveryState*"
+        }
+      ],
+      "argsoriginal": "(const ImGuiErrorRecoveryState* state_in)",
+      "call_args": "(state_in)",
+      "cimguiname": "igErrorRecoveryTryToRecoverWindowState",
+      "defaults": {},
+      "funcname": "ErrorRecoveryTryToRecoverWindowState",
+      "location": "imgui_internal:3774",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igErrorRecoveryTryToRecoverWindowState",
+      "ret": "void",
+      "signature": "(const ImGuiErrorRecoveryState*)",
+      "stname": ""
+    }
+  ],
+  "igFindBestWindowPosForPopup": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igFindBestWindowPosForPopup",
+      "defaults": {},
+      "funcname": "FindBestWindowPosForPopup",
+      "location": "imgui_internal:3351",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igFindBestWindowPosForPopup",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igFindBestWindowPosForPopupEx": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "ref_pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "last_dir",
+          "type": "ImGuiDir*"
+        },
+        {
+          "name": "r_outer",
+          "type": "const ImRect"
+        },
+        {
+          "name": "r_avoid",
+          "type": "const ImRect"
+        },
+        {
+          "name": "policy",
+          "type": "ImGuiPopupPositionPolicy"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& ref_pos,const ImVec2& size,ImGuiDir* last_dir,const ImRect& r_outer,const ImRect& r_avoid,ImGuiPopupPositionPolicy policy)",
+      "call_args": "(ref_pos,size,last_dir,r_outer,r_avoid,policy)",
+      "cimguiname": "igFindBestWindowPosForPopupEx",
+      "defaults": {},
+      "funcname": "FindBestWindowPosForPopupEx",
+      "location": "imgui_internal:3352",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igFindBestWindowPosForPopupEx",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImGuiDir*,const ImRect,const ImRect,ImGuiPopupPositionPolicy)",
+      "stname": ""
+    }
+  ],
+  "igFindBlockingModal": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igFindBlockingModal",
+      "defaults": {},
+      "funcname": "FindBlockingModal",
+      "location": "imgui_internal:3350",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindBlockingModal",
+      "ret": "ImGuiWindow*",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igFindBottomMostVisibleWindowWithinBeginStack": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igFindBottomMostVisibleWindowWithinBeginStack",
+      "defaults": {},
+      "funcname": "FindBottomMostVisibleWindowWithinBeginStack",
+      "location": "imgui_internal:3227",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindBottomMostVisibleWindowWithinBeginStack",
+      "ret": "ImGuiWindow*",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igFindHoveredViewportFromPlatformWindowStack": [
+    {
+      "args": "(const ImVec2 mouse_platform_pos)",
+      "argsT": [
+        {
+          "name": "mouse_platform_pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& mouse_platform_pos)",
+      "call_args": "(mouse_platform_pos)",
+      "cimguiname": "igFindHoveredViewportFromPlatformWindowStack",
+      "defaults": {},
+      "funcname": "FindHoveredViewportFromPlatformWindowStack",
+      "location": "imgui_internal:3263",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindHoveredViewportFromPlatformWindowStack",
+      "ret": "ImGuiViewportP*",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igFindHoveredWindowEx": [
+    {
+      "args": "(const ImVec2 pos,bool find_first_and_in_any_viewport,ImGuiWindow** out_hovered_window,ImGuiWindow** out_hovered_window_under_moving_window)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "find_first_and_in_any_viewport",
+          "type": "bool"
+        },
+        {
+          "name": "out_hovered_window",
+          "type": "ImGuiWindow**"
+        },
+        {
+          "name": "out_hovered_window_under_moving_window",
+          "type": "ImGuiWindow**"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,bool find_first_and_in_any_viewport,ImGuiWindow** out_hovered_window,ImGuiWindow** out_hovered_window_under_moving_window)",
+      "call_args": "(pos,find_first_and_in_any_viewport,out_hovered_window,out_hovered_window_under_moving_window)",
+      "cimguiname": "igFindHoveredWindowEx",
+      "defaults": {},
+      "funcname": "FindHoveredWindowEx",
+      "location": "imgui_internal:3245",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindHoveredWindowEx",
+      "ret": "void",
+      "signature": "(const ImVec2,bool,ImGuiWindow**,ImGuiWindow**)",
+      "stname": ""
+    }
+  ],
+  "igFindOrCreateColumns": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiID id)",
+      "call_args": "(window,id)",
+      "cimguiname": "igFindOrCreateColumns",
+      "defaults": {},
+      "funcname": "FindOrCreateColumns",
+      "location": "imgui_internal:3580",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindOrCreateColumns",
+      "ret": "ImGuiOldColumns*",
+      "signature": "(ImGuiWindow*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igFindRenderedTextEnd": [
+    {
+      "args": "(const char* text,const char* text_end)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
+      "call_args": "(text,text_end)",
+      "cimguiname": "igFindRenderedTextEnd",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "FindRenderedTextEnd",
+      "location": "imgui_internal:3678",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindRenderedTextEnd",
+      "ret": "const char*",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igFindSettingsHandler": [
+    {
+      "args": "(const char* type_name)",
+      "argsT": [
+        {
+          "name": "type_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* type_name)",
+      "call_args": "(type_name)",
+      "cimguiname": "igFindSettingsHandler",
+      "defaults": {},
+      "funcname": "FindSettingsHandler",
+      "location": "imgui_internal:3271",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindSettingsHandler",
+      "ret": "ImGuiSettingsHandler*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igFindViewportByID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igFindViewportByID",
+      "defaults": {},
+      "funcname": "FindViewportByID",
+      "location": "imgui:1091",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindViewportByID",
+      "ret": "ImGuiViewport*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igFindViewportByPlatformHandle": [
+    {
+      "args": "(void* platform_handle)",
+      "argsT": [
+        {
+          "name": "platform_handle",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void* platform_handle)",
+      "call_args": "(platform_handle)",
+      "cimguiname": "igFindViewportByPlatformHandle",
+      "defaults": {},
+      "funcname": "FindViewportByPlatformHandle",
+      "location": "imgui:1092",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindViewportByPlatformHandle",
+      "ret": "ImGuiViewport*",
+      "signature": "(void*)",
+      "stname": ""
+    }
+  ],
+  "igFindWindowByID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igFindWindowByID",
+      "defaults": {},
+      "funcname": "FindWindowByID",
+      "location": "imgui_internal:3199",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindWindowByID",
+      "ret": "ImGuiWindow*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igFindWindowByName": [
+    {
+      "args": "(const char* name)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "igFindWindowByName",
+      "defaults": {},
+      "funcname": "FindWindowByName",
+      "location": "imgui_internal:3200",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindWindowByName",
+      "ret": "ImGuiWindow*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igFindWindowDisplayIndex": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igFindWindowDisplayIndex",
+      "defaults": {},
+      "funcname": "FindWindowDisplayIndex",
+      "location": "imgui_internal:3226",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindWindowDisplayIndex",
+      "ret": "int",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igFindWindowSettingsByID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igFindWindowSettingsByID",
+      "defaults": {},
+      "funcname": "FindWindowSettingsByID",
+      "location": "imgui_internal:3275",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindWindowSettingsByID",
+      "ret": "ImGuiWindowSettings*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igFindWindowSettingsByWindow": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igFindWindowSettingsByWindow",
+      "defaults": {},
+      "funcname": "FindWindowSettingsByWindow",
+      "location": "imgui_internal:3276",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFindWindowSettingsByWindow",
+      "ret": "ImGuiWindowSettings*",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igFixupKeyChord": [
+    {
+      "args": "(ImGuiKeyChord key_chord)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord)",
+      "call_args": "(key_chord)",
+      "cimguiname": "igFixupKeyChord",
+      "defaults": {},
+      "funcname": "FixupKeyChord",
+      "location": "imgui_internal:3403",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFixupKeyChord",
+      "ret": "ImGuiKeyChord",
+      "signature": "(ImGuiKeyChord)",
+      "stname": ""
+    }
+  ],
+  "igFocusItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igFocusItem",
+      "defaults": {},
+      "funcname": "FocusItem",
+      "location": "imgui_internal:3390",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFocusItem",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igFocusTopMostWindowUnderOne": [
+    {
+      "args": "(ImGuiWindow* under_this_window,ImGuiWindow* ignore_window,ImGuiViewport* filter_viewport,ImGuiFocusRequestFlags flags)",
+      "argsT": [
+        {
+          "name": "under_this_window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "ignore_window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "filter_viewport",
+          "type": "ImGuiViewport*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiFocusRequestFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* under_this_window,ImGuiWindow* ignore_window,ImGuiViewport* filter_viewport,ImGuiFocusRequestFlags flags)",
+      "call_args": "(under_this_window,ignore_window,filter_viewport,flags)",
+      "cimguiname": "igFocusTopMostWindowUnderOne",
+      "defaults": {},
+      "funcname": "FocusTopMostWindowUnderOne",
+      "location": "imgui_internal:3221",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFocusTopMostWindowUnderOne",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiWindow*,ImGuiViewport*,ImGuiFocusRequestFlags)",
+      "stname": ""
+    }
+  ],
+  "igFocusWindow": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiFocusRequestFlags flags)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiFocusRequestFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiFocusRequestFlags flags=0)",
+      "call_args": "(window,flags)",
+      "cimguiname": "igFocusWindow",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "FocusWindow",
+      "location": "imgui_internal:3220",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igFocusWindow",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiFocusRequestFlags)",
+      "stname": ""
+    }
+  ],
+  "igGcAwakeTransientWindowBuffers": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igGcAwakeTransientWindowBuffers",
+      "defaults": {},
+      "funcname": "GcAwakeTransientWindowBuffers",
+      "location": "imgui_internal:3768",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGcAwakeTransientWindowBuffers",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igGcCompactTransientMiscBuffers": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGcCompactTransientMiscBuffers",
+      "defaults": {},
+      "funcname": "GcCompactTransientMiscBuffers",
+      "location": "imgui_internal:3766",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGcCompactTransientMiscBuffers",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGcCompactTransientWindowBuffers": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igGcCompactTransientWindowBuffers",
+      "defaults": {},
+      "funcname": "GcCompactTransientWindowBuffers",
+      "location": "imgui_internal:3767",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGcCompactTransientWindowBuffers",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igGetActiveID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetActiveID",
+      "defaults": {},
+      "funcname": "GetActiveID",
+      "location": "imgui_internal:3300",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetActiveID",
+      "ret": "ImGuiID",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetAllocatorFunctions": [
+    {
+      "args": "(ImGuiMemAllocFunc* p_alloc_func,ImGuiMemFreeFunc* p_free_func,void** p_user_data)",
+      "argsT": [
+        {
+          "name": "p_alloc_func",
+          "type": "ImGuiMemAllocFunc*"
+        },
+        {
+          "name": "p_free_func",
+          "type": "ImGuiMemFreeFunc*"
+        },
+        {
+          "name": "p_user_data",
+          "type": "void**"
+        }
+      ],
+      "argsoriginal": "(ImGuiMemAllocFunc* p_alloc_func,ImGuiMemFreeFunc* p_free_func,void** p_user_data)",
+      "call_args": "(p_alloc_func,p_free_func,p_user_data)",
+      "cimguiname": "igGetAllocatorFunctions",
+      "defaults": {},
+      "funcname": "GetAllocatorFunctions",
+      "location": "imgui:1081",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetAllocatorFunctions",
+      "ret": "void",
+      "signature": "(ImGuiMemAllocFunc*,ImGuiMemFreeFunc*,void**)",
+      "stname": ""
+    }
+  ],
+  "igGetBackgroundDrawList": [
+    {
+      "args": "(ImGuiViewport* viewport)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewport*"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewport* viewport=((void*)0))",
+      "call_args": "(viewport)",
+      "cimguiname": "igGetBackgroundDrawList",
+      "defaults": {
+        "viewport": "NULL"
+      },
+      "funcname": "GetBackgroundDrawList",
+      "location": "imgui:970",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetBackgroundDrawList",
+      "ret": "ImDrawList*",
+      "signature": "(ImGuiViewport*)",
+      "stname": ""
+    }
+  ],
+  "igGetBoxSelectState": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igGetBoxSelectState",
+      "defaults": {},
+      "funcname": "GetBoxSelectState",
+      "location": "imgui_internal:3569",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetBoxSelectState",
+      "ret": "ImGuiBoxSelectState*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igGetClipboardText": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetClipboardText",
+      "defaults": {},
+      "funcname": "GetClipboardText",
+      "location": "imgui:1053",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetClipboardText",
+      "ret": "const char*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetColorU32": [
+    {
+      "args": "(ImGuiCol idx,float alpha_mul)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiCol"
+        },
+        {
+          "name": "alpha_mul",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiCol idx,float alpha_mul=1.0f)",
+      "call_args": "(idx,alpha_mul)",
+      "cimguiname": "igGetColorU32",
+      "defaults": {
+        "alpha_mul": "1.0f"
+      },
+      "funcname": "GetColorU32",
+      "location": "imgui:475",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColorU32_Col",
+      "ret": "ImU32",
+      "signature": "(ImGuiCol,float)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImVec4 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col)",
+      "call_args": "(col)",
+      "cimguiname": "igGetColorU32",
+      "defaults": {},
+      "funcname": "GetColorU32",
+      "location": "imgui:476",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColorU32_Vec4",
+      "ret": "ImU32",
+      "signature": "(const ImVec4)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU32 col,float alpha_mul)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "alpha_mul",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImU32 col,float alpha_mul=1.0f)",
+      "call_args": "(col,alpha_mul)",
+      "cimguiname": "igGetColorU32",
+      "defaults": {
+        "alpha_mul": "1.0f"
+      },
+      "funcname": "GetColorU32",
+      "location": "imgui:477",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColorU32_U32",
+      "ret": "ImU32",
+      "signature": "(ImU32,float)",
+      "stname": ""
+    }
+  ],
+  "igGetColumnIndex": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetColumnIndex",
+      "defaults": {},
+      "funcname": "GetColumnIndex",
+      "location": "imgui:860",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnIndex",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetColumnNormFromOffset": [
+    {
+      "args": "(const ImGuiOldColumns* columns,float offset)",
+      "argsT": [
+        {
+          "name": "columns",
+          "type": "const ImGuiOldColumns*"
+        },
+        {
+          "name": "offset",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImGuiOldColumns* columns,float offset)",
+      "call_args": "(columns,offset)",
+      "cimguiname": "igGetColumnNormFromOffset",
+      "defaults": {},
+      "funcname": "GetColumnNormFromOffset",
+      "location": "imgui_internal:3582",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnNormFromOffset",
+      "ret": "float",
+      "signature": "(const ImGuiOldColumns*,float)",
+      "stname": ""
+    }
+  ],
+  "igGetColumnOffset": [
+    {
+      "args": "(int column_index)",
+      "argsT": [
+        {
+          "name": "column_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_index=-1)",
+      "call_args": "(column_index)",
+      "cimguiname": "igGetColumnOffset",
+      "defaults": {
+        "column_index": "-1"
+      },
+      "funcname": "GetColumnOffset",
+      "location": "imgui:863",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnOffset",
+      "ret": "float",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igGetColumnOffsetFromNorm": [
+    {
+      "args": "(const ImGuiOldColumns* columns,float offset_norm)",
+      "argsT": [
+        {
+          "name": "columns",
+          "type": "const ImGuiOldColumns*"
+        },
+        {
+          "name": "offset_norm",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImGuiOldColumns* columns,float offset_norm)",
+      "call_args": "(columns,offset_norm)",
+      "cimguiname": "igGetColumnOffsetFromNorm",
+      "defaults": {},
+      "funcname": "GetColumnOffsetFromNorm",
+      "location": "imgui_internal:3581",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnOffsetFromNorm",
+      "ret": "float",
+      "signature": "(const ImGuiOldColumns*,float)",
+      "stname": ""
+    }
+  ],
+  "igGetColumnWidth": [
+    {
+      "args": "(int column_index)",
+      "argsT": [
+        {
+          "name": "column_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_index=-1)",
+      "call_args": "(column_index)",
+      "cimguiname": "igGetColumnWidth",
+      "defaults": {
+        "column_index": "-1"
+      },
+      "funcname": "GetColumnWidth",
+      "location": "imgui:861",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnWidth",
+      "ret": "float",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igGetColumnsCount": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetColumnsCount",
+      "defaults": {},
+      "funcname": "GetColumnsCount",
+      "location": "imgui:865",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnsCount",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetColumnsID": [
+    {
+      "args": "(const char* str_id,int count)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,int count)",
+      "call_args": "(str_id,count)",
+      "cimguiname": "igGetColumnsID",
+      "defaults": {},
+      "funcname": "GetColumnsID",
+      "location": "imgui_internal:3579",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetColumnsID",
+      "ret": "ImGuiID",
+      "signature": "(const char*,int)",
+      "stname": ""
+    }
+  ],
+  "igGetContentRegionAvail": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetContentRegionAvail",
+      "defaults": {},
+      "funcname": "GetContentRegionAvail",
+      "location": "imgui:492",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetContentRegionAvail",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCurrentContext": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCurrentContext",
+      "defaults": {},
+      "funcname": "GetCurrentContext",
+      "location": "imgui:333",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCurrentContext",
+      "ret": "ImGuiContext*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCurrentFocusScope": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCurrentFocusScope",
+      "defaults": {},
+      "funcname": "GetCurrentFocusScope",
+      "location": "imgui_internal:3543",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCurrentFocusScope",
+      "ret": "ImGuiID",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCurrentTabBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCurrentTabBar",
+      "defaults": {},
+      "funcname": "GetCurrentTabBar",
+      "location": "imgui_internal:3641",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCurrentTabBar",
+      "ret": "ImGuiTabBar*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCurrentTable": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCurrentTable",
+      "defaults": {},
+      "funcname": "GetCurrentTable",
+      "location": "imgui_internal:3596",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCurrentTable",
+      "ret": "ImGuiTable*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCurrentWindow": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCurrentWindow",
+      "defaults": {},
+      "funcname": "GetCurrentWindow",
+      "location": "imgui_internal:3198",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCurrentWindow",
+      "ret": "ImGuiWindow*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCurrentWindowRead": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCurrentWindowRead",
+      "defaults": {},
+      "funcname": "GetCurrentWindowRead",
+      "location": "imgui_internal:3197",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCurrentWindowRead",
+      "ret": "ImGuiWindow*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCursorPos": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCursorPos",
+      "defaults": {},
+      "funcname": "GetCursorPos",
+      "location": "imgui:493",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetCursorPos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCursorPosX": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCursorPosX",
+      "defaults": {},
+      "funcname": "GetCursorPosX",
+      "location": "imgui:494",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCursorPosX",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCursorPosY": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCursorPosY",
+      "defaults": {},
+      "funcname": "GetCursorPosY",
+      "location": "imgui:495",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetCursorPosY",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCursorScreenPos": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCursorScreenPos",
+      "defaults": {},
+      "funcname": "GetCursorScreenPos",
+      "location": "imgui:490",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetCursorScreenPos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetCursorStartPos": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetCursorStartPos",
+      "defaults": {},
+      "funcname": "GetCursorStartPos",
+      "location": "imgui:499",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetCursorStartPos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetDefaultFont": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetDefaultFont",
+      "defaults": {},
+      "funcname": "GetDefaultFont",
+      "location": "imgui_internal:3234",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetDefaultFont",
+      "ret": "ImFont*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetDragDropPayload": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetDragDropPayload",
+      "defaults": {},
+      "funcname": "GetDragDropPayload",
+      "location": "imgui:917",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetDragDropPayload",
+      "ret": "const ImGuiPayload*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetDrawData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetDrawData",
+      "defaults": {},
+      "funcname": "GetDrawData",
+      "location": "imgui:343",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetDrawData",
+      "ret": "ImDrawData*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetDrawListSharedData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetDrawListSharedData",
+      "defaults": {},
+      "funcname": "GetDrawListSharedData",
+      "location": "imgui:978",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetDrawListSharedData",
+      "ret": "ImDrawListSharedData*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetFocusID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFocusID",
+      "defaults": {},
+      "funcname": "GetFocusID",
+      "location": "imgui_internal:3301",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetFocusID",
+      "ret": "ImGuiID",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetFont": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFont",
+      "defaults": {},
+      "funcname": "GetFont",
+      "location": "imgui:472",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetFont",
+      "ret": "ImFont*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetFontSize": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFontSize",
+      "defaults": {},
+      "funcname": "GetFontSize",
+      "location": "imgui:473",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetFontSize",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetFontTexUvWhitePixel": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFontTexUvWhitePixel",
+      "defaults": {},
+      "funcname": "GetFontTexUvWhitePixel",
+      "location": "imgui:474",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetFontTexUvWhitePixel",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetForegroundDrawList": [
+    {
+      "args": "(ImGuiViewport* viewport)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewport*"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewport* viewport=((void*)0))",
+      "call_args": "(viewport)",
+      "cimguiname": "igGetForegroundDrawList",
+      "defaults": {
+        "viewport": "NULL"
+      },
+      "funcname": "GetForegroundDrawList",
+      "location": "imgui:971",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetForegroundDrawList_ViewportPtr",
+      "ret": "ImDrawList*",
+      "signature": "(ImGuiViewport*)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igGetForegroundDrawList",
+      "defaults": {},
+      "funcname": "GetForegroundDrawList",
+      "location": "imgui_internal:3235",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetForegroundDrawList_WindowPtr",
+      "ret": "ImDrawList*",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igGetFrameCount": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFrameCount",
+      "defaults": {},
+      "funcname": "GetFrameCount",
+      "location": "imgui:977",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetFrameCount",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetFrameHeight": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFrameHeight",
+      "defaults": {},
+      "funcname": "GetFrameHeight",
+      "location": "imgui:514",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetFrameHeight",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetFrameHeightWithSpacing": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetFrameHeightWithSpacing",
+      "defaults": {},
+      "funcname": "GetFrameHeightWithSpacing",
+      "location": "imgui:515",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetFrameHeightWithSpacing",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetHoveredID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetHoveredID",
+      "defaults": {},
+      "funcname": "GetHoveredID",
+      "location": "imgui_internal:3305",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetHoveredID",
+      "ret": "ImGuiID",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetID": [
+    {
+      "args": "(const char* str_id)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str_id)",
+      "call_args": "(str_id)",
+      "cimguiname": "igGetID",
+      "defaults": {},
+      "funcname": "GetID",
+      "location": "imgui:533",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetID_Str",
+      "ret": "ImGuiID",
+      "signature": "(const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* str_id_begin,const char* str_id_end)",
+      "argsT": [
+        {
+          "name": "str_id_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "str_id_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str_id_begin,const char* str_id_end)",
+      "call_args": "(str_id_begin,str_id_end)",
+      "cimguiname": "igGetID",
+      "defaults": {},
+      "funcname": "GetID",
+      "location": "imgui:534",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetID_StrStr",
+      "ret": "ImGuiID",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id)",
+      "call_args": "(ptr_id)",
+      "cimguiname": "igGetID",
+      "defaults": {},
+      "funcname": "GetID",
+      "location": "imgui:535",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetID_Ptr",
+      "ret": "ImGuiID",
+      "signature": "(const void*)",
+      "stname": ""
+    },
+    {
+      "args": "(int int_id)",
+      "argsT": [
+        {
+          "name": "int_id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int int_id)",
+      "call_args": "(int_id)",
+      "cimguiname": "igGetID",
+      "defaults": {},
+      "funcname": "GetID",
+      "location": "imgui:536",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetID_Int",
+      "ret": "ImGuiID",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igGetIDWithSeed": [
+    {
+      "args": "(const char* str_id_begin,const char* str_id_end,ImGuiID seed)",
+      "argsT": [
+        {
+          "name": "str_id_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "str_id_end",
+          "type": "const char*"
+        },
+        {
+          "name": "seed",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const char* str_id_begin,const char* str_id_end,ImGuiID seed)",
+      "call_args": "(str_id_begin,str_id_end,seed)",
+      "cimguiname": "igGetIDWithSeed",
+      "defaults": {},
+      "funcname": "GetIDWithSeed",
+      "location": "imgui_internal:3310",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetIDWithSeed_Str",
+      "ret": "ImGuiID",
+      "signature": "(const char*,const char*,ImGuiID)",
+      "stname": ""
+    },
+    {
+      "args": "(int n,ImGuiID seed)",
+      "argsT": [
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "seed",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(int n,ImGuiID seed)",
+      "call_args": "(n,seed)",
+      "cimguiname": "igGetIDWithSeed",
+      "defaults": {},
+      "funcname": "GetIDWithSeed",
+      "location": "imgui_internal:3311",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetIDWithSeed_Int",
+      "ret": "ImGuiID",
+      "signature": "(int,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igGetIO": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetIO",
+      "defaults": {},
+      "funcname": "GetIO",
+      "location": "imgui:337",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetIO",
+      "ret": "ImGuiIO*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetIOEx": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igGetIOEx",
+      "defaults": {},
+      "funcname": "GetIOEx",
+      "location": "imgui_internal:3195",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetIOEx",
+      "ret": "ImGuiIO*",
+      "retref": "&",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igGetInputTextState": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igGetInputTextState",
+      "defaults": {},
+      "funcname": "GetInputTextState",
+      "location": "imgui_internal:3749",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetInputTextState",
+      "ret": "ImGuiInputTextState*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igGetItemFlags": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetItemFlags",
+      "defaults": {},
+      "funcname": "GetItemFlags",
+      "location": "imgui_internal:3299",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetItemFlags",
+      "ret": "ImGuiItemFlags",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetItemID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetItemID",
+      "defaults": {},
+      "funcname": "GetItemID",
+      "location": "imgui:958",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetItemID",
+      "ret": "ImGuiID",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetItemRectMax": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetItemRectMax",
+      "defaults": {},
+      "funcname": "GetItemRectMax",
+      "location": "imgui:960",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetItemRectMax",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetItemRectMin": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetItemRectMin",
+      "defaults": {},
+      "funcname": "GetItemRectMin",
+      "location": "imgui:959",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetItemRectMin",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetItemRectSize": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetItemRectSize",
+      "defaults": {},
+      "funcname": "GetItemRectSize",
+      "location": "imgui:961",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetItemRectSize",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetItemStatusFlags": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetItemStatusFlags",
+      "defaults": {},
+      "funcname": "GetItemStatusFlags",
+      "location": "imgui_internal:3298",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetItemStatusFlags",
+      "ret": "ImGuiItemStatusFlags",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetKeyChordName": [
+    {
+      "args": "(ImGuiKeyChord key_chord)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord)",
+      "call_args": "(key_chord)",
+      "cimguiname": "igGetKeyChordName",
+      "defaults": {},
+      "funcname": "GetKeyChordName",
+      "location": "imgui_internal:3415",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyChordName",
+      "ret": "const char*",
+      "signature": "(ImGuiKeyChord)",
+      "stname": ""
+    }
+  ],
+  "igGetKeyData": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiKey key)",
+      "call_args": "(ctx,key)",
+      "cimguiname": "igGetKeyData",
+      "defaults": {},
+      "funcname": "GetKeyData",
+      "location": "imgui_internal:3413",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyData_ContextPtr",
+      "ret": "ImGuiKeyData*",
+      "signature": "(ImGuiContext*,ImGuiKey)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igGetKeyData",
+      "defaults": {},
+      "funcname": "GetKeyData",
+      "location": "imgui_internal:3414",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyData_Key",
+      "ret": "ImGuiKeyData*",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igGetKeyMagnitude2d": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "key_left",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "key_right",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "key_up",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "key_down",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down)",
+      "call_args": "(key_left,key_right,key_up,key_down)",
+      "cimguiname": "igGetKeyMagnitude2d",
+      "defaults": {},
+      "funcname": "GetKeyMagnitude2d",
+      "location": "imgui_internal:3418",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetKeyMagnitude2d",
+      "ret": "void",
+      "signature": "(ImGuiKey,ImGuiKey,ImGuiKey,ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igGetKeyName": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igGetKeyName",
+      "defaults": {},
+      "funcname": "GetKeyName",
+      "location": "imgui:1001",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyName",
+      "ret": "const char*",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igGetKeyOwner": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igGetKeyOwner",
+      "defaults": {},
+      "funcname": "GetKeyOwner",
+      "location": "imgui_internal:3437",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyOwner",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igGetKeyOwnerData": [
+    {
+      "args": "(ImGuiContext* ctx,ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx,ImGuiKey key)",
+      "call_args": "(ctx,key)",
+      "cimguiname": "igGetKeyOwnerData",
+      "defaults": {},
+      "funcname": "GetKeyOwnerData",
+      "location": "imgui_internal:3442",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyOwnerData",
+      "ret": "ImGuiKeyOwnerData*",
+      "signature": "(ImGuiContext*,ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igGetKeyPressedAmount": [
+    {
+      "args": "(ImGuiKey key,float repeat_delay,float rate)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "repeat_delay",
+          "type": "float"
+        },
+        {
+          "name": "rate",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,float repeat_delay,float rate)",
+      "call_args": "(key,repeat_delay,rate)",
+      "cimguiname": "igGetKeyPressedAmount",
+      "defaults": {},
+      "funcname": "GetKeyPressedAmount",
+      "location": "imgui:1000",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetKeyPressedAmount",
+      "ret": "int",
+      "signature": "(ImGuiKey,float,float)",
+      "stname": ""
+    }
+  ],
+  "igGetMainViewport": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetMainViewport",
+      "defaults": {},
+      "funcname": "GetMainViewport",
+      "location": "imgui:967",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetMainViewport",
+      "ret": "ImGuiViewport*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetMouseClickedCount": [
+    {
+      "args": "(ImGuiMouseButton button)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button)",
+      "call_args": "(button)",
+      "cimguiname": "igGetMouseClickedCount",
+      "defaults": {},
+      "funcname": "GetMouseClickedCount",
+      "location": "imgui:1038",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetMouseClickedCount",
+      "ret": "int",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    }
+  ],
+  "igGetMouseCursor": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetMouseCursor",
+      "defaults": {},
+      "funcname": "GetMouseCursor",
+      "location": "imgui:1047",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetMouseCursor",
+      "ret": "ImGuiMouseCursor",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetMouseDragDelta": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "lock_threshold",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button=0,float lock_threshold=-1.0f)",
+      "call_args": "(button,lock_threshold)",
+      "cimguiname": "igGetMouseDragDelta",
+      "defaults": {
+        "button": "0",
+        "lock_threshold": "-1.0f"
+      },
+      "funcname": "GetMouseDragDelta",
+      "location": "imgui:1045",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetMouseDragDelta",
+      "ret": "void",
+      "signature": "(ImGuiMouseButton,float)",
+      "stname": ""
+    }
+  ],
+  "igGetMousePos": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetMousePos",
+      "defaults": {},
+      "funcname": "GetMousePos",
+      "location": "imgui:1042",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetMousePos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetMousePosOnOpeningCurrentPopup": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetMousePosOnOpeningCurrentPopup",
+      "defaults": {},
+      "funcname": "GetMousePosOnOpeningCurrentPopup",
+      "location": "imgui:1043",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetMousePosOnOpeningCurrentPopup",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetMultiSelectState": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igGetMultiSelectState",
+      "defaults": {},
+      "funcname": "GetMultiSelectState",
+      "location": "imgui_internal:3570",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetMultiSelectState",
+      "ret": "ImGuiMultiSelectState*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igGetNavTweakPressedAmount": [
+    {
+      "args": "(ImGuiAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        }
+      ],
+      "argsoriginal": "(ImGuiAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "igGetNavTweakPressedAmount",
+      "defaults": {},
+      "funcname": "GetNavTweakPressedAmount",
+      "location": "imgui_internal:3419",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetNavTweakPressedAmount",
+      "ret": "float",
+      "signature": "(ImGuiAxis)",
+      "stname": ""
+    }
+  ],
+  "igGetPlatformIO": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetPlatformIO",
+      "defaults": {},
+      "funcname": "GetPlatformIO",
+      "location": "imgui:338",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetPlatformIO",
+      "ret": "ImGuiPlatformIO*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetPlatformIOEx": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igGetPlatformIOEx",
+      "defaults": {},
+      "funcname": "GetPlatformIOEx",
+      "location": "imgui_internal:3196",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetPlatformIOEx",
+      "ret": "ImGuiPlatformIO*",
+      "retref": "&",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igGetPopupAllowedExtentRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igGetPopupAllowedExtentRect",
+      "defaults": {},
+      "funcname": "GetPopupAllowedExtentRect",
+      "location": "imgui_internal:3347",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetPopupAllowedExtentRect",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igGetScrollMaxX": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetScrollMaxX",
+      "defaults": {},
+      "funcname": "GetScrollMaxX",
+      "location": "imgui:441",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetScrollMaxX",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetScrollMaxY": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetScrollMaxY",
+      "defaults": {},
+      "funcname": "GetScrollMaxY",
+      "location": "imgui:442",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetScrollMaxY",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetScrollX": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetScrollX",
+      "defaults": {},
+      "funcname": "GetScrollX",
+      "location": "imgui:437",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetScrollX",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetScrollY": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetScrollY",
+      "defaults": {},
+      "funcname": "GetScrollY",
+      "location": "imgui:438",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetScrollY",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetShortcutRoutingData": [
+    {
+      "args": "(ImGuiKeyChord key_chord)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord)",
+      "call_args": "(key_chord)",
+      "cimguiname": "igGetShortcutRoutingData",
+      "defaults": {},
+      "funcname": "GetShortcutRoutingData",
+      "location": "imgui_internal:3476",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetShortcutRoutingData",
+      "ret": "ImGuiKeyRoutingData*",
+      "signature": "(ImGuiKeyChord)",
+      "stname": ""
+    }
+  ],
+  "igGetStateStorage": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetStateStorage",
+      "defaults": {},
+      "funcname": "GetStateStorage",
+      "location": "imgui:981",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetStateStorage",
+      "ret": "ImGuiStorage*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetStyle": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetStyle",
+      "defaults": {},
+      "funcname": "GetStyle",
+      "location": "imgui:339",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetStyle",
+      "ret": "ImGuiStyle*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetStyleColorName": [
+    {
+      "args": "(ImGuiCol idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiCol"
+        }
+      ],
+      "argsoriginal": "(ImGuiCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "igGetStyleColorName",
+      "defaults": {},
+      "funcname": "GetStyleColorName",
+      "location": "imgui:979",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetStyleColorName",
+      "ret": "const char*",
+      "signature": "(ImGuiCol)",
+      "stname": ""
+    }
+  ],
+  "igGetStyleColorVec4": [
+    {
+      "args": "(ImGuiCol idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiCol"
+        }
+      ],
+      "argsoriginal": "(ImGuiCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "igGetStyleColorVec4",
+      "defaults": {},
+      "funcname": "GetStyleColorVec4",
+      "location": "imgui:478",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetStyleColorVec4",
+      "ret": "const ImVec4*",
+      "retref": "&",
+      "signature": "(ImGuiCol)",
+      "stname": ""
+    }
+  ],
+  "igGetStyleVarInfo": [
+    {
+      "args": "(ImGuiStyleVar idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx)",
+      "call_args": "(idx)",
+      "cimguiname": "igGetStyleVarInfo",
+      "defaults": {},
+      "funcname": "GetStyleVarInfo",
+      "location": "imgui_internal:3327",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetStyleVarInfo",
+      "ret": "const ImGuiDataVarInfo*",
+      "signature": "(ImGuiStyleVar)",
+      "stname": ""
+    }
+  ],
+  "igGetTextLineHeight": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetTextLineHeight",
+      "defaults": {},
+      "funcname": "GetTextLineHeight",
+      "location": "imgui:512",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTextLineHeight",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetTextLineHeightWithSpacing": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetTextLineHeightWithSpacing",
+      "defaults": {},
+      "funcname": "GetTextLineHeightWithSpacing",
+      "location": "imgui:513",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTextLineHeightWithSpacing",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetTime": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetTime",
+      "defaults": {},
+      "funcname": "GetTime",
+      "location": "imgui:976",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTime",
+      "ret": "double",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetTopMostAndVisiblePopupModal": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetTopMostAndVisiblePopupModal",
+      "defaults": {},
+      "funcname": "GetTopMostAndVisiblePopupModal",
+      "location": "imgui_internal:3349",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTopMostAndVisiblePopupModal",
+      "ret": "ImGuiWindow*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetTopMostPopupModal": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetTopMostPopupModal",
+      "defaults": {},
+      "funcname": "GetTopMostPopupModal",
+      "location": "imgui_internal:3348",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTopMostPopupModal",
+      "ret": "ImGuiWindow*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetTreeNodeToLabelSpacing": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetTreeNodeToLabelSpacing",
+      "defaults": {},
+      "funcname": "GetTreeNodeToLabelSpacing",
+      "location": "imgui:677",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTreeNodeToLabelSpacing",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetTypematicRepeatRate": [
+    {
+      "args": "(ImGuiInputFlags flags,float* repeat_delay,float* repeat_rate)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        },
+        {
+          "name": "repeat_delay",
+          "type": "float*"
+        },
+        {
+          "name": "repeat_rate",
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(ImGuiInputFlags flags,float* repeat_delay,float* repeat_rate)",
+      "call_args": "(flags,repeat_delay,repeat_rate)",
+      "cimguiname": "igGetTypematicRepeatRate",
+      "defaults": {},
+      "funcname": "GetTypematicRepeatRate",
+      "location": "imgui_internal:3421",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTypematicRepeatRate",
+      "ret": "void",
+      "signature": "(ImGuiInputFlags,float*,float*)",
+      "stname": ""
+    }
+  ],
+  "igGetTypingSelectRequest": [
+    {
+      "args": "(ImGuiTypingSelectFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiTypingSelectFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiTypingSelectFlags flags=ImGuiTypingSelectFlags_None)",
+      "call_args": "(flags)",
+      "cimguiname": "igGetTypingSelectRequest",
+      "defaults": {
+        "flags": "ImGuiTypingSelectFlags_None"
+      },
+      "funcname": "GetTypingSelectRequest",
+      "location": "imgui_internal:3555",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetTypingSelectRequest",
+      "ret": "ImGuiTypingSelectRequest*",
+      "signature": "(ImGuiTypingSelectFlags)",
+      "stname": ""
+    }
+  ],
+  "igGetVersion": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetVersion",
+      "defaults": {},
+      "funcname": "GetVersion",
+      "location": "imgui:355",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetVersion",
+      "ret": "const char*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetViewportPlatformMonitor": [
+    {
+      "args": "(ImGuiViewport* viewport)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewport*"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewport* viewport)",
+      "call_args": "(viewport)",
+      "cimguiname": "igGetViewportPlatformMonitor",
+      "defaults": {},
+      "funcname": "GetViewportPlatformMonitor",
+      "location": "imgui_internal:3262",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetViewportPlatformMonitor",
+      "ret": "const ImGuiPlatformMonitor*",
+      "signature": "(ImGuiViewport*)",
+      "stname": ""
+    }
+  ],
+  "igGetWindowAlwaysWantOwnTabBar": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igGetWindowAlwaysWantOwnTabBar",
+      "defaults": {},
+      "funcname": "GetWindowAlwaysWantOwnTabBar",
+      "location": "imgui_internal:3503",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowAlwaysWantOwnTabBar",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igGetWindowDockID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowDockID",
+      "defaults": {},
+      "funcname": "GetWindowDockID",
+      "location": "imgui:893",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowDockID",
+      "ret": "ImGuiID",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowDockNode": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowDockNode",
+      "defaults": {},
+      "funcname": "GetWindowDockNode",
+      "location": "imgui_internal:3502",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowDockNode",
+      "ret": "ImGuiDockNode*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowDpiScale": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowDpiScale",
+      "defaults": {},
+      "funcname": "GetWindowDpiScale",
+      "location": "imgui:406",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowDpiScale",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowDrawList": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowDrawList",
+      "defaults": {},
+      "funcname": "GetWindowDrawList",
+      "location": "imgui:405",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowDrawList",
+      "ret": "ImDrawList*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowHeight": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowHeight",
+      "defaults": {},
+      "funcname": "GetWindowHeight",
+      "location": "imgui:410",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowHeight",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowPos": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowPos",
+      "defaults": {},
+      "funcname": "GetWindowPos",
+      "location": "imgui:407",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetWindowPos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowResizeBorderID": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiDir dir)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "dir",
+          "type": "ImGuiDir"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiDir dir)",
+      "call_args": "(window,dir)",
+      "cimguiname": "igGetWindowResizeBorderID",
+      "defaults": {},
+      "funcname": "GetWindowResizeBorderID",
+      "location": "imgui_internal:3709",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowResizeBorderID",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiWindow*,ImGuiDir)",
+      "stname": ""
+    }
+  ],
+  "igGetWindowResizeCornerID": [
+    {
+      "args": "(ImGuiWindow* window,int n)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,int n)",
+      "call_args": "(window,n)",
+      "cimguiname": "igGetWindowResizeCornerID",
+      "defaults": {},
+      "funcname": "GetWindowResizeCornerID",
+      "location": "imgui_internal:3708",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowResizeCornerID",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiWindow*,int)",
+      "stname": ""
+    }
+  ],
+  "igGetWindowScrollbarID": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiAxis axis)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiAxis axis)",
+      "call_args": "(window,axis)",
+      "cimguiname": "igGetWindowScrollbarID",
+      "defaults": {},
+      "funcname": "GetWindowScrollbarID",
+      "location": "imgui_internal:3707",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowScrollbarID",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiWindow*,ImGuiAxis)",
+      "stname": ""
+    }
+  ],
+  "igGetWindowScrollbarRect": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiAxis axis)",
+      "call_args": "(window,axis)",
+      "cimguiname": "igGetWindowScrollbarRect",
+      "defaults": {},
+      "funcname": "GetWindowScrollbarRect",
+      "location": "imgui_internal:3706",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetWindowScrollbarRect",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiAxis)",
+      "stname": ""
+    }
+  ],
+  "igGetWindowSize": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowSize",
+      "defaults": {},
+      "funcname": "GetWindowSize",
+      "location": "imgui:408",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igGetWindowSize",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowViewport": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowViewport",
+      "defaults": {},
+      "funcname": "GetWindowViewport",
+      "location": "imgui:411",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowViewport",
+      "ret": "ImGuiViewport*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igGetWindowWidth": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igGetWindowWidth",
+      "defaults": {},
+      "funcname": "GetWindowWidth",
+      "location": "imgui:409",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igGetWindowWidth",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igImAbs": [
+    {
+      "args": "(int x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int x)",
+      "call_args": "(x)",
+      "cimguiname": "igImAbs",
+      "defaults": {},
+      "funcname": "ImAbs",
+      "location": "imgui_internal:457",
+      "ov_cimguiname": "igImAbs_Int",
+      "ret": "int",
+      "signature": "(int)",
+      "stname": ""
+    },
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "igImAbs",
+      "defaults": {},
+      "funcname": "ImAbs",
+      "location": "imgui_internal:458",
+      "ov_cimguiname": "igImAbs_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "igImAbs",
+      "defaults": {},
+      "funcname": "ImAbs",
+      "location": "imgui_internal:459",
+      "ov_cimguiname": "igImAbs_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "igImAlphaBlendColors": [
+    {
+      "args": "(ImU32 col_a,ImU32 col_b)",
+      "argsT": [
+        {
+          "name": "col_a",
+          "type": "ImU32"
+        },
+        {
+          "name": "col_b",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col_a,ImU32 col_b)",
+      "call_args": "(col_a,col_b)",
+      "cimguiname": "igImAlphaBlendColors",
+      "defaults": {},
+      "funcname": "ImAlphaBlendColors",
+      "location": "imgui_internal:368",
+      "ov_cimguiname": "igImAlphaBlendColors",
+      "ret": "ImU32",
+      "signature": "(ImU32,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igImBezierCubicCalc": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,float t)",
+      "call_args": "(p1,p2,p3,p4,t)",
+      "cimguiname": "igImBezierCubicCalc",
+      "defaults": {},
+      "funcname": "ImBezierCubicCalc",
+      "location": "imgui_internal:504",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImBezierCubicCalc",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igImBezierCubicClosestPoint": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "num_segments",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,const ImVec2& p,int num_segments)",
+      "call_args": "(p1,p2,p3,p4,p,num_segments)",
+      "cimguiname": "igImBezierCubicClosestPoint",
+      "defaults": {},
+      "funcname": "ImBezierCubicClosestPoint",
+      "location": "imgui_internal:505",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImBezierCubicClosestPoint",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,int)",
+      "stname": ""
+    }
+  ],
+  "igImBezierCubicClosestPointCasteljau": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p4",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "tess_tol",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,const ImVec2& p4,const ImVec2& p,float tess_tol)",
+      "call_args": "(p1,p2,p3,p4,p,tess_tol)",
+      "cimguiname": "igImBezierCubicClosestPointCasteljau",
+      "defaults": {},
+      "funcname": "ImBezierCubicClosestPointCasteljau",
+      "location": "imgui_internal:506",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImBezierCubicClosestPointCasteljau",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igImBezierQuadraticCalc": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "p1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p3",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p1,const ImVec2& p2,const ImVec2& p3,float t)",
+      "call_args": "(p1,p2,p3,t)",
+      "cimguiname": "igImBezierQuadraticCalc",
+      "defaults": {},
+      "funcname": "ImBezierQuadraticCalc",
+      "location": "imgui_internal:507",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImBezierQuadraticCalc",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igImBitArrayClearAllBits": [
+    {
+      "args": "(ImU32* arr,int bitcount)",
+      "argsT": [
+        {
+          "name": "arr",
+          "type": "ImU32*"
+        },
+        {
+          "name": "bitcount",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImU32* arr,int bitcount)",
+      "call_args": "(arr,bitcount)",
+      "cimguiname": "igImBitArrayClearAllBits",
+      "defaults": {},
+      "funcname": "ImBitArrayClearAllBits",
+      "location": "imgui_internal:577",
+      "ov_cimguiname": "igImBitArrayClearAllBits",
+      "ret": "void",
+      "signature": "(ImU32*,int)",
+      "stname": ""
+    }
+  ],
+  "igImBitArrayClearBit": [
+    {
+      "args": "(ImU32* arr,int n)",
+      "argsT": [
+        {
+          "name": "arr",
+          "type": "ImU32*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImU32* arr,int n)",
+      "call_args": "(arr,n)",
+      "cimguiname": "igImBitArrayClearBit",
+      "defaults": {},
+      "funcname": "ImBitArrayClearBit",
+      "location": "imgui_internal:579",
+      "ov_cimguiname": "igImBitArrayClearBit",
+      "ret": "void",
+      "signature": "(ImU32*,int)",
+      "stname": ""
+    }
+  ],
+  "igImBitArrayGetStorageSizeInBytes": [
+    {
+      "args": "(int bitcount)",
+      "argsT": [
+        {
+          "name": "bitcount",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int bitcount)",
+      "call_args": "(bitcount)",
+      "cimguiname": "igImBitArrayGetStorageSizeInBytes",
+      "defaults": {},
+      "funcname": "ImBitArrayGetStorageSizeInBytes",
+      "location": "imgui_internal:576",
+      "ov_cimguiname": "igImBitArrayGetStorageSizeInBytes",
+      "ret": "size_t",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igImBitArraySetBit": [
+    {
+      "args": "(ImU32* arr,int n)",
+      "argsT": [
+        {
+          "name": "arr",
+          "type": "ImU32*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImU32* arr,int n)",
+      "call_args": "(arr,n)",
+      "cimguiname": "igImBitArraySetBit",
+      "defaults": {},
+      "funcname": "ImBitArraySetBit",
+      "location": "imgui_internal:580",
+      "ov_cimguiname": "igImBitArraySetBit",
+      "ret": "void",
+      "signature": "(ImU32*,int)",
+      "stname": ""
+    }
+  ],
+  "igImBitArraySetBitRange": [
+    {
+      "args": "(ImU32* arr,int n,int n2)",
+      "argsT": [
+        {
+          "name": "arr",
+          "type": "ImU32*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "n2",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImU32* arr,int n,int n2)",
+      "call_args": "(arr,n,n2)",
+      "cimguiname": "igImBitArraySetBitRange",
+      "defaults": {},
+      "funcname": "ImBitArraySetBitRange",
+      "location": "imgui_internal:581",
+      "ov_cimguiname": "igImBitArraySetBitRange",
+      "ret": "void",
+      "signature": "(ImU32*,int,int)",
+      "stname": ""
+    }
+  ],
+  "igImBitArrayTestBit": [
+    {
+      "args": "(const ImU32* arr,int n)",
+      "argsT": [
+        {
+          "name": "arr",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU32* arr,int n)",
+      "call_args": "(arr,n)",
+      "cimguiname": "igImBitArrayTestBit",
+      "defaults": {},
+      "funcname": "ImBitArrayTestBit",
+      "location": "imgui_internal:578",
+      "ov_cimguiname": "igImBitArrayTestBit",
+      "ret": "bool",
+      "signature": "(const ImU32*,int)",
+      "stname": ""
+    }
+  ],
+  "igImCharIsBlankA": [
+    {
+      "args": "(char c)",
+      "argsT": [
+        {
+          "name": "c",
+          "type": "char"
+        }
+      ],
+      "argsoriginal": "(char c)",
+      "call_args": "(c)",
+      "cimguiname": "igImCharIsBlankA",
+      "defaults": {},
+      "funcname": "ImCharIsBlankA",
+      "location": "imgui_internal:390",
+      "ov_cimguiname": "igImCharIsBlankA",
+      "ret": "bool",
+      "signature": "(char)",
+      "stname": ""
+    }
+  ],
+  "igImCharIsBlankW": [
+    {
+      "args": "(unsigned int c)",
+      "argsT": [
+        {
+          "name": "c",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(unsigned int c)",
+      "call_args": "(c)",
+      "cimguiname": "igImCharIsBlankW",
+      "defaults": {},
+      "funcname": "ImCharIsBlankW",
+      "location": "imgui_internal:391",
+      "ov_cimguiname": "igImCharIsBlankW",
+      "ret": "bool",
+      "signature": "(unsigned int)",
+      "stname": ""
+    }
+  ],
+  "igImCharIsXdigitA": [
+    {
+      "args": "(char c)",
+      "argsT": [
+        {
+          "name": "c",
+          "type": "char"
+        }
+      ],
+      "argsoriginal": "(char c)",
+      "call_args": "(c)",
+      "cimguiname": "igImCharIsXdigitA",
+      "defaults": {},
+      "funcname": "ImCharIsXdigitA",
+      "location": "imgui_internal:392",
+      "ov_cimguiname": "igImCharIsXdigitA",
+      "ret": "bool",
+      "signature": "(char)",
+      "stname": ""
+    }
+  ],
+  "igImClamp": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 v,const ImVec2 mn,const ImVec2 mx)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "v",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "mn",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "mx",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& v,const ImVec2&mn,const ImVec2&mx)",
+      "call_args": "(v,mn,mx)",
+      "cimguiname": "igImClamp",
+      "defaults": {},
+      "funcname": "ImClamp",
+      "location": "imgui_internal:481",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImClamp",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImDot": [
+    {
+      "args": "(const ImVec2 a,const ImVec2 b)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b)",
+      "call_args": "(a,b)",
+      "cimguiname": "igImDot",
+      "defaults": {},
+      "funcname": "ImDot",
+      "location": "imgui_internal:494",
+      "ov_cimguiname": "igImDot",
+      "ret": "float",
+      "signature": "(const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImExponentialMovingAverage": [
+    {
+      "args": "(float avg,float sample,int n)",
+      "argsT": [
+        {
+          "name": "avg",
+          "type": "float"
+        },
+        {
+          "name": "sample",
+          "type": "float"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(float avg,float sample,int n)",
+      "call_args": "(avg,sample,n)",
+      "cimguiname": "igImExponentialMovingAverage",
+      "defaults": {},
+      "funcname": "ImExponentialMovingAverage",
+      "location": "imgui_internal:500",
+      "ov_cimguiname": "igImExponentialMovingAverage",
+      "ret": "float",
+      "signature": "(float,float,int)",
+      "stname": ""
+    }
+  ],
+  "igImFileClose": [
+    {
+      "args": "(ImFileHandle file)",
+      "argsT": [
+        {
+          "name": "file",
+          "type": "ImFileHandle"
+        }
+      ],
+      "argsoriginal": "(ImFileHandle file)",
+      "call_args": "(file)",
+      "cimguiname": "igImFileClose",
+      "defaults": {},
+      "funcname": "ImFileClose",
+      "location": "imgui_internal:431",
+      "ov_cimguiname": "igImFileClose",
+      "ret": "bool",
+      "signature": "(ImFileHandle)",
+      "stname": ""
+    }
+  ],
+  "igImFileGetSize": [
+    {
+      "args": "(ImFileHandle file)",
+      "argsT": [
+        {
+          "name": "file",
+          "type": "ImFileHandle"
+        }
+      ],
+      "argsoriginal": "(ImFileHandle file)",
+      "call_args": "(file)",
+      "cimguiname": "igImFileGetSize",
+      "defaults": {},
+      "funcname": "ImFileGetSize",
+      "location": "imgui_internal:432",
+      "ov_cimguiname": "igImFileGetSize",
+      "ret": "ImU64",
+      "signature": "(ImFileHandle)",
+      "stname": ""
+    }
+  ],
+  "igImFileLoadToMemory": [
+    {
+      "args": "(const char* filename,const char* mode,size_t* out_file_size,int padding_bytes)",
+      "argsT": [
+        {
+          "name": "filename",
+          "type": "const char*"
+        },
+        {
+          "name": "mode",
+          "type": "const char*"
+        },
+        {
+          "name": "out_file_size",
+          "type": "size_t*"
+        },
+        {
+          "name": "padding_bytes",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* filename,const char* mode,size_t* out_file_size=((void*)0),int padding_bytes=0)",
+      "call_args": "(filename,mode,out_file_size,padding_bytes)",
+      "cimguiname": "igImFileLoadToMemory",
+      "defaults": {
+        "out_file_size": "NULL",
+        "padding_bytes": "0"
+      },
+      "funcname": "ImFileLoadToMemory",
+      "location": "imgui_internal:438",
+      "ov_cimguiname": "igImFileLoadToMemory",
+      "ret": "void*",
+      "signature": "(const char*,const char*,size_t*,int)",
+      "stname": ""
+    }
+  ],
+  "igImFileOpen": [
+    {
+      "args": "(const char* filename,const char* mode)",
+      "argsT": [
+        {
+          "name": "filename",
+          "type": "const char*"
+        },
+        {
+          "name": "mode",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* filename,const char* mode)",
+      "call_args": "(filename,mode)",
+      "cimguiname": "igImFileOpen",
+      "defaults": {},
+      "funcname": "ImFileOpen",
+      "location": "imgui_internal:430",
+      "ov_cimguiname": "igImFileOpen",
+      "ret": "ImFileHandle",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImFileRead": [
+    {
+      "args": "(void* data,ImU64 size,ImU64 count,ImFileHandle file)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "size",
+          "type": "ImU64"
+        },
+        {
+          "name": "count",
+          "type": "ImU64"
+        },
+        {
+          "name": "file",
+          "type": "ImFileHandle"
+        }
+      ],
+      "argsoriginal": "(void* data,ImU64 size,ImU64 count,ImFileHandle file)",
+      "call_args": "(data,size,count,file)",
+      "cimguiname": "igImFileRead",
+      "defaults": {},
+      "funcname": "ImFileRead",
+      "location": "imgui_internal:433",
+      "ov_cimguiname": "igImFileRead",
+      "ret": "ImU64",
+      "signature": "(void*,ImU64,ImU64,ImFileHandle)",
+      "stname": ""
+    }
+  ],
+  "igImFileWrite": [
+    {
+      "args": "(const void* data,ImU64 size,ImU64 count,ImFileHandle file)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "const void*"
+        },
+        {
+          "name": "size",
+          "type": "ImU64"
+        },
+        {
+          "name": "count",
+          "type": "ImU64"
+        },
+        {
+          "name": "file",
+          "type": "ImFileHandle"
+        }
+      ],
+      "argsoriginal": "(const void* data,ImU64 size,ImU64 count,ImFileHandle file)",
+      "call_args": "(data,size,count,file)",
+      "cimguiname": "igImFileWrite",
+      "defaults": {},
+      "funcname": "ImFileWrite",
+      "location": "imgui_internal:434",
+      "ov_cimguiname": "igImFileWrite",
+      "ret": "ImU64",
+      "signature": "(const void*,ImU64,ImU64,ImFileHandle)",
+      "stname": ""
+    }
+  ],
+  "igImFloor": [
+    {
+      "args": "(float f)",
+      "argsT": [
+        {
+          "name": "f",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float f)",
+      "call_args": "(f)",
+      "cimguiname": "igImFloor",
+      "defaults": {},
+      "funcname": "ImFloor",
+      "location": "imgui_internal:491",
+      "ov_cimguiname": "igImFloor_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 v)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "v",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& v)",
+      "call_args": "(v)",
+      "cimguiname": "igImFloor",
+      "defaults": {},
+      "funcname": "ImFloor",
+      "location": "imgui_internal:492",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImFloor_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildFinish": [
+    {
+      "args": "(ImFontAtlas* atlas)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas)",
+      "call_args": "(atlas)",
+      "cimguiname": "igImFontAtlasBuildFinish",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildFinish",
+      "location": "imgui_internal:3852",
+      "ov_cimguiname": "igImFontAtlasBuildFinish",
+      "ret": "void",
+      "signature": "(ImFontAtlas*)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildInit": [
+    {
+      "args": "(ImFontAtlas* atlas)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas)",
+      "call_args": "(atlas)",
+      "cimguiname": "igImFontAtlasBuildInit",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildInit",
+      "location": "imgui_internal:3849",
+      "ov_cimguiname": "igImFontAtlasBuildInit",
+      "ret": "void",
+      "signature": "(ImFontAtlas*)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildMultiplyCalcLookupTable": [
+    {
+      "args": "(unsigned char out_table[256],float in_multiply_factor)",
+      "argsT": [
+        {
+          "name": "out_table",
+          "type": "unsigned char[256]"
+        },
+        {
+          "name": "in_multiply_factor",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(unsigned char out_table[256],float in_multiply_factor)",
+      "call_args": "(out_table,in_multiply_factor)",
+      "cimguiname": "igImFontAtlasBuildMultiplyCalcLookupTable",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildMultiplyCalcLookupTable",
+      "location": "imgui_internal:3855",
+      "ov_cimguiname": "igImFontAtlasBuildMultiplyCalcLookupTable",
+      "ret": "void",
+      "signature": "(unsigned char[256],float)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildMultiplyRectAlpha8": [
+    {
+      "args": "(const unsigned char table[256],unsigned char* pixels,int x,int y,int w,int h,int stride)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "const unsigned char[256]"
+        },
+        {
+          "name": "pixels",
+          "type": "unsigned char*"
+        },
+        {
+          "name": "x",
+          "type": "int"
+        },
+        {
+          "name": "y",
+          "type": "int"
+        },
+        {
+          "name": "w",
+          "type": "int"
+        },
+        {
+          "name": "h",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const unsigned char table[256],unsigned char* pixels,int x,int y,int w,int h,int stride)",
+      "call_args": "(table,pixels,x,y,w,h,stride)",
+      "cimguiname": "igImFontAtlasBuildMultiplyRectAlpha8",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildMultiplyRectAlpha8",
+      "location": "imgui_internal:3856",
+      "ov_cimguiname": "igImFontAtlasBuildMultiplyRectAlpha8",
+      "ret": "void",
+      "signature": "(const unsigned char[256],unsigned char*,int,int,int,int,int)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildPackCustomRects": [
+    {
+      "args": "(ImFontAtlas* atlas,void* stbrp_context_opaque)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "stbrp_context_opaque",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas,void* stbrp_context_opaque)",
+      "call_args": "(atlas,stbrp_context_opaque)",
+      "cimguiname": "igImFontAtlasBuildPackCustomRects",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildPackCustomRects",
+      "location": "imgui_internal:3851",
+      "ov_cimguiname": "igImFontAtlasBuildPackCustomRects",
+      "ret": "void",
+      "signature": "(ImFontAtlas*,void*)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildRender32bppRectFromString": [
+    {
+      "args": "(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned int in_marker_pixel_value)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "x",
+          "type": "int"
+        },
+        {
+          "name": "y",
+          "type": "int"
+        },
+        {
+          "name": "w",
+          "type": "int"
+        },
+        {
+          "name": "h",
+          "type": "int"
+        },
+        {
+          "name": "in_str",
+          "type": "const char*"
+        },
+        {
+          "name": "in_marker_char",
+          "type": "char"
+        },
+        {
+          "name": "in_marker_pixel_value",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned int in_marker_pixel_value)",
+      "call_args": "(atlas,x,y,w,h,in_str,in_marker_char,in_marker_pixel_value)",
+      "cimguiname": "igImFontAtlasBuildRender32bppRectFromString",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildRender32bppRectFromString",
+      "location": "imgui_internal:3854",
+      "ov_cimguiname": "igImFontAtlasBuildRender32bppRectFromString",
+      "ret": "void",
+      "signature": "(ImFontAtlas*,int,int,int,int,const char*,char,unsigned int)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildRender8bppRectFromString": [
+    {
+      "args": "(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned char in_marker_pixel_value)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "x",
+          "type": "int"
+        },
+        {
+          "name": "y",
+          "type": "int"
+        },
+        {
+          "name": "w",
+          "type": "int"
+        },
+        {
+          "name": "h",
+          "type": "int"
+        },
+        {
+          "name": "in_str",
+          "type": "const char*"
+        },
+        {
+          "name": "in_marker_char",
+          "type": "char"
+        },
+        {
+          "name": "in_marker_pixel_value",
+          "type": "unsigned char"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas,int x,int y,int w,int h,const char* in_str,char in_marker_char,unsigned char in_marker_pixel_value)",
+      "call_args": "(atlas,x,y,w,h,in_str,in_marker_char,in_marker_pixel_value)",
+      "cimguiname": "igImFontAtlasBuildRender8bppRectFromString",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildRender8bppRectFromString",
+      "location": "imgui_internal:3853",
+      "ov_cimguiname": "igImFontAtlasBuildRender8bppRectFromString",
+      "ret": "void",
+      "signature": "(ImFontAtlas*,int,int,int,int,const char*,char,unsigned char)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasBuildSetupFont": [
+    {
+      "args": "(ImFontAtlas* atlas,ImFont* font,ImFontConfig* font_config,float ascent,float descent)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        },
+        {
+          "name": "font",
+          "type": "ImFont*"
+        },
+        {
+          "name": "font_config",
+          "type": "ImFontConfig*"
+        },
+        {
+          "name": "ascent",
+          "type": "float"
+        },
+        {
+          "name": "descent",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas,ImFont* font,ImFontConfig* font_config,float ascent,float descent)",
+      "call_args": "(atlas,font,font_config,ascent,descent)",
+      "cimguiname": "igImFontAtlasBuildSetupFont",
+      "defaults": {},
+      "funcname": "ImFontAtlasBuildSetupFont",
+      "location": "imgui_internal:3850",
+      "ov_cimguiname": "igImFontAtlasBuildSetupFont",
+      "ret": "void",
+      "signature": "(ImFontAtlas*,ImFont*,ImFontConfig*,float,float)",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasGetBuilderForStbTruetype": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igImFontAtlasGetBuilderForStbTruetype",
+      "defaults": {},
+      "funcname": "ImFontAtlasGetBuilderForStbTruetype",
+      "location": "imgui_internal:3846",
+      "ov_cimguiname": "igImFontAtlasGetBuilderForStbTruetype",
+      "ret": "const ImFontBuilderIO*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igImFontAtlasUpdateConfigDataPointers": [
+    {
+      "args": "(ImFontAtlas* atlas)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas)",
+      "call_args": "(atlas)",
+      "cimguiname": "igImFontAtlasUpdateConfigDataPointers",
+      "defaults": {},
+      "funcname": "ImFontAtlasUpdateConfigDataPointers",
+      "location": "imgui_internal:3848",
+      "ov_cimguiname": "igImFontAtlasUpdateConfigDataPointers",
+      "ret": "void",
+      "signature": "(ImFontAtlas*)",
+      "stname": ""
+    }
+  ],
+  "igImFormatString": [
+    {
+      "args": "(char* buf,size_t buf_size,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "size_t"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(char* buf,size_t buf_size,const char* fmt,...)",
+      "call_args": "(buf,buf_size,fmt,...)",
+      "cimguiname": "igImFormatString",
+      "defaults": {},
+      "funcname": "ImFormatString",
+      "isvararg": "...)",
+      "location": "imgui_internal:396",
+      "ov_cimguiname": "igImFormatString",
+      "ret": "int",
+      "signature": "(char*,size_t,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igImFormatStringToTempBuffer": [
+    {
+      "args": "(const char** out_buf,const char** out_buf_end,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "out_buf",
+          "type": "const char**"
+        },
+        {
+          "name": "out_buf_end",
+          "type": "const char**"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char** out_buf,const char** out_buf_end,const char* fmt,...)",
+      "call_args": "(out_buf,out_buf_end,fmt,...)",
+      "cimguiname": "igImFormatStringToTempBuffer",
+      "defaults": {},
+      "funcname": "ImFormatStringToTempBuffer",
+      "isvararg": "...)",
+      "location": "imgui_internal:398",
+      "ov_cimguiname": "igImFormatStringToTempBuffer",
+      "ret": "void",
+      "signature": "(const char**,const char**,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igImFormatStringToTempBufferV": [
+    {
+      "args": "(const char** out_buf,const char** out_buf_end,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "out_buf",
+          "type": "const char**"
+        },
+        {
+          "name": "out_buf_end",
+          "type": "const char**"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char** out_buf,const char** out_buf_end,const char* fmt,va_list args)",
+      "call_args": "(out_buf,out_buf_end,fmt,args)",
+      "cimguiname": "igImFormatStringToTempBufferV",
+      "defaults": {},
+      "funcname": "ImFormatStringToTempBufferV",
+      "location": "imgui_internal:399",
+      "ov_cimguiname": "igImFormatStringToTempBufferV",
+      "ret": "void",
+      "signature": "(const char**,const char**,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igImFormatStringV": [
+    {
+      "args": "(char* buf,size_t buf_size,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "size_t"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(char* buf,size_t buf_size,const char* fmt,va_list args)",
+      "call_args": "(buf,buf_size,fmt,args)",
+      "cimguiname": "igImFormatStringV",
+      "defaults": {},
+      "funcname": "ImFormatStringV",
+      "location": "imgui_internal:397",
+      "ov_cimguiname": "igImFormatStringV",
+      "ret": "int",
+      "signature": "(char*,size_t,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igImHashData": [
+    {
+      "args": "(const void* data,size_t data_size,ImGuiID seed)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "const void*"
+        },
+        {
+          "name": "data_size",
+          "type": "size_t"
+        },
+        {
+          "name": "seed",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const void* data,size_t data_size,ImGuiID seed=0)",
+      "call_args": "(data,data_size,seed)",
+      "cimguiname": "igImHashData",
+      "defaults": {
+        "seed": "0"
+      },
+      "funcname": "ImHashData",
+      "location": "imgui_internal:359",
+      "ov_cimguiname": "igImHashData",
+      "ret": "ImGuiID",
+      "signature": "(const void*,size_t,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igImHashStr": [
+    {
+      "args": "(const char* data,size_t data_size,ImGuiID seed)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "const char*"
+        },
+        {
+          "name": "data_size",
+          "type": "size_t"
+        },
+        {
+          "name": "seed",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const char* data,size_t data_size=0,ImGuiID seed=0)",
+      "call_args": "(data,data_size,seed)",
+      "cimguiname": "igImHashStr",
+      "defaults": {
+        "data_size": "0",
+        "seed": "0"
+      },
+      "funcname": "ImHashStr",
+      "location": "imgui_internal:360",
+      "ov_cimguiname": "igImHashStr",
+      "ret": "ImGuiID",
+      "signature": "(const char*,size_t,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igImInvLength": [
+    {
+      "args": "(const ImVec2 lhs,float fail_value)",
+      "argsT": [
+        {
+          "name": "lhs",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "fail_value",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& lhs,float fail_value)",
+      "call_args": "(lhs,fail_value)",
+      "cimguiname": "igImInvLength",
+      "defaults": {},
+      "funcname": "ImInvLength",
+      "location": "imgui_internal:488",
+      "ov_cimguiname": "igImInvLength",
+      "ret": "float",
+      "signature": "(const ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igImIsFloatAboveGuaranteedIntegerPrecision": [
+    {
+      "args": "(float f)",
+      "argsT": [
+        {
+          "name": "f",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float f)",
+      "call_args": "(f)",
+      "cimguiname": "igImIsFloatAboveGuaranteedIntegerPrecision",
+      "defaults": {},
+      "funcname": "ImIsFloatAboveGuaranteedIntegerPrecision",
+      "location": "imgui_internal:499",
+      "ov_cimguiname": "igImIsFloatAboveGuaranteedIntegerPrecision",
+      "ret": "bool",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igImIsPowerOfTwo": [
+    {
+      "args": "(int v)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int v)",
+      "call_args": "(v)",
+      "cimguiname": "igImIsPowerOfTwo",
+      "defaults": {},
+      "funcname": "ImIsPowerOfTwo",
+      "location": "imgui_internal:371",
+      "ov_cimguiname": "igImIsPowerOfTwo_Int",
+      "ret": "bool",
+      "signature": "(int)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU64 v)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "ImU64"
+        }
+      ],
+      "argsoriginal": "(ImU64 v)",
+      "call_args": "(v)",
+      "cimguiname": "igImIsPowerOfTwo",
+      "defaults": {},
+      "funcname": "ImIsPowerOfTwo",
+      "location": "imgui_internal:372",
+      "ov_cimguiname": "igImIsPowerOfTwo_U64",
+      "ret": "bool",
+      "signature": "(ImU64)",
+      "stname": ""
+    }
+  ],
+  "igImLengthSqr": [
+    {
+      "args": "(const ImVec2 lhs)",
+      "argsT": [
+        {
+          "name": "lhs",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& lhs)",
+      "call_args": "(lhs)",
+      "cimguiname": "igImLengthSqr",
+      "defaults": {},
+      "funcname": "ImLengthSqr",
+      "location": "imgui_internal:486",
+      "ov_cimguiname": "igImLengthSqr_Vec2",
+      "ret": "float",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImVec4 lhs)",
+      "argsT": [
+        {
+          "name": "lhs",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& lhs)",
+      "call_args": "(lhs)",
+      "cimguiname": "igImLengthSqr",
+      "defaults": {},
+      "funcname": "ImLengthSqr",
+      "location": "imgui_internal:487",
+      "ov_cimguiname": "igImLengthSqr_Vec4",
+      "ret": "float",
+      "signature": "(const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "igImLerp": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,float t)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,float t)",
+      "call_args": "(a,b,t)",
+      "cimguiname": "igImLerp",
+      "defaults": {},
+      "funcname": "ImLerp",
+      "location": "imgui_internal:482",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImLerp_Vec2Float",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 t)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "t",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& t)",
+      "call_args": "(a,b,t)",
+      "cimguiname": "igImLerp",
+      "defaults": {},
+      "funcname": "ImLerp",
+      "location": "imgui_internal:483",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImLerp_Vec2Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVec4 *pOut,const ImVec4 a,const ImVec4 b,float t)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& a,const ImVec4& b,float t)",
+      "call_args": "(a,b,t)",
+      "cimguiname": "igImLerp",
+      "defaults": {},
+      "funcname": "ImLerp",
+      "location": "imgui_internal:484",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImLerp_Vec4",
+      "ret": "void",
+      "signature": "(const ImVec4,const ImVec4,float)",
+      "stname": ""
+    }
+  ],
+  "igImLineClosestPoint": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& p)",
+      "call_args": "(a,b,p)",
+      "cimguiname": "igImLineClosestPoint",
+      "defaults": {},
+      "funcname": "ImLineClosestPoint",
+      "location": "imgui_internal:508",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImLineClosestPoint",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImLinearRemapClamp": [
+    {
+      "args": "(float s0,float s1,float d0,float d1,float x)",
+      "argsT": [
+        {
+          "name": "s0",
+          "type": "float"
+        },
+        {
+          "name": "s1",
+          "type": "float"
+        },
+        {
+          "name": "d0",
+          "type": "float"
+        },
+        {
+          "name": "d1",
+          "type": "float"
+        },
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float s0,float s1,float d0,float d1,float x)",
+      "call_args": "(s0,s1,d0,d1,x)",
+      "cimguiname": "igImLinearRemapClamp",
+      "defaults": {},
+      "funcname": "ImLinearRemapClamp",
+      "location": "imgui_internal:497",
+      "ov_cimguiname": "igImLinearRemapClamp",
+      "ret": "float",
+      "signature": "(float,float,float,float,float)",
+      "stname": ""
+    }
+  ],
+  "igImLinearSweep": [
+    {
+      "args": "(float current,float target,float speed)",
+      "argsT": [
+        {
+          "name": "current",
+          "type": "float"
+        },
+        {
+          "name": "target",
+          "type": "float"
+        },
+        {
+          "name": "speed",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float current,float target,float speed)",
+      "call_args": "(current,target,speed)",
+      "cimguiname": "igImLinearSweep",
+      "defaults": {},
+      "funcname": "ImLinearSweep",
+      "location": "imgui_internal:496",
+      "ov_cimguiname": "igImLinearSweep",
+      "ret": "float",
+      "signature": "(float,float,float)",
+      "stname": ""
+    }
+  ],
+  "igImLog": [
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "igImLog",
+      "defaults": {},
+      "funcname": "ImLog",
+      "location": "imgui_internal:455",
+      "ov_cimguiname": "igImLog_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "igImLog",
+      "defaults": {},
+      "funcname": "ImLog",
+      "location": "imgui_internal:456",
+      "ov_cimguiname": "igImLog_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "igImLowerBound": [
+    {
+      "args": "(ImGuiStoragePair* in_begin,ImGuiStoragePair* in_end,ImGuiID key)",
+      "argsT": [
+        {
+          "name": "in_begin",
+          "type": "ImGuiStoragePair*"
+        },
+        {
+          "name": "in_end",
+          "type": "ImGuiStoragePair*"
+        },
+        {
+          "name": "key",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiStoragePair* in_begin,ImGuiStoragePair* in_end,ImGuiID key)",
+      "call_args": "(in_begin,in_end,key)",
+      "cimguiname": "igImLowerBound",
+      "defaults": {},
+      "funcname": "ImLowerBound",
+      "location": "imgui_internal:747",
+      "ov_cimguiname": "igImLowerBound",
+      "ret": "ImGuiStoragePair*",
+      "signature": "(ImGuiStoragePair*,ImGuiStoragePair*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igImMax": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "lhs",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rhs",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& lhs,const ImVec2& rhs)",
+      "call_args": "(lhs,rhs)",
+      "cimguiname": "igImMax",
+      "defaults": {},
+      "funcname": "ImMax",
+      "location": "imgui_internal:480",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImMax",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImMin": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "lhs",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rhs",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& lhs,const ImVec2& rhs)",
+      "call_args": "(lhs,rhs)",
+      "cimguiname": "igImMin",
+      "defaults": {},
+      "funcname": "ImMin",
+      "location": "imgui_internal:479",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImMin",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImModPositive": [
+    {
+      "args": "(int a,int b)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "int"
+        },
+        {
+          "name": "b",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int a,int b)",
+      "call_args": "(a,b)",
+      "cimguiname": "igImModPositive",
+      "defaults": {},
+      "funcname": "ImModPositive",
+      "location": "imgui_internal:493",
+      "ov_cimguiname": "igImModPositive",
+      "ret": "int",
+      "signature": "(int,int)",
+      "stname": ""
+    }
+  ],
+  "igImMul": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "lhs",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rhs",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& lhs,const ImVec2& rhs)",
+      "call_args": "(lhs,rhs)",
+      "cimguiname": "igImMul",
+      "defaults": {},
+      "funcname": "ImMul",
+      "location": "imgui_internal:498",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImMul",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImParseFormatFindEnd": [
+    {
+      "args": "(const char* format)",
+      "argsT": [
+        {
+          "name": "format",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* format)",
+      "call_args": "(format)",
+      "cimguiname": "igImParseFormatFindEnd",
+      "defaults": {},
+      "funcname": "ImParseFormatFindEnd",
+      "location": "imgui_internal:401",
+      "ov_cimguiname": "igImParseFormatFindEnd",
+      "ret": "const char*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igImParseFormatFindStart": [
+    {
+      "args": "(const char* format)",
+      "argsT": [
+        {
+          "name": "format",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* format)",
+      "call_args": "(format)",
+      "cimguiname": "igImParseFormatFindStart",
+      "defaults": {},
+      "funcname": "ImParseFormatFindStart",
+      "location": "imgui_internal:400",
+      "ov_cimguiname": "igImParseFormatFindStart",
+      "ret": "const char*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igImParseFormatPrecision": [
+    {
+      "args": "(const char* format,int default_value)",
+      "argsT": [
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "default_value",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* format,int default_value)",
+      "call_args": "(format,default_value)",
+      "cimguiname": "igImParseFormatPrecision",
+      "defaults": {},
+      "funcname": "ImParseFormatPrecision",
+      "location": "imgui_internal:405",
+      "ov_cimguiname": "igImParseFormatPrecision",
+      "ret": "int",
+      "signature": "(const char*,int)",
+      "stname": ""
+    }
+  ],
+  "igImParseFormatSanitizeForPrinting": [
+    {
+      "args": "(const char* fmt_in,char* fmt_out,size_t fmt_out_size)",
+      "argsT": [
+        {
+          "name": "fmt_in",
+          "type": "const char*"
+        },
+        {
+          "name": "fmt_out",
+          "type": "char*"
+        },
+        {
+          "name": "fmt_out_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* fmt_in,char* fmt_out,size_t fmt_out_size)",
+      "call_args": "(fmt_in,fmt_out,fmt_out_size)",
+      "cimguiname": "igImParseFormatSanitizeForPrinting",
+      "defaults": {},
+      "funcname": "ImParseFormatSanitizeForPrinting",
+      "location": "imgui_internal:403",
+      "ov_cimguiname": "igImParseFormatSanitizeForPrinting",
+      "ret": "void",
+      "signature": "(const char*,char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igImParseFormatSanitizeForScanning": [
+    {
+      "args": "(const char* fmt_in,char* fmt_out,size_t fmt_out_size)",
+      "argsT": [
+        {
+          "name": "fmt_in",
+          "type": "const char*"
+        },
+        {
+          "name": "fmt_out",
+          "type": "char*"
+        },
+        {
+          "name": "fmt_out_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* fmt_in,char* fmt_out,size_t fmt_out_size)",
+      "call_args": "(fmt_in,fmt_out,fmt_out_size)",
+      "cimguiname": "igImParseFormatSanitizeForScanning",
+      "defaults": {},
+      "funcname": "ImParseFormatSanitizeForScanning",
+      "location": "imgui_internal:404",
+      "ov_cimguiname": "igImParseFormatSanitizeForScanning",
+      "ret": "const char*",
+      "signature": "(const char*,char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igImParseFormatTrimDecorations": [
+    {
+      "args": "(const char* format,char* buf,size_t buf_size)",
+      "argsT": [
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* format,char* buf,size_t buf_size)",
+      "call_args": "(format,buf,buf_size)",
+      "cimguiname": "igImParseFormatTrimDecorations",
+      "defaults": {},
+      "funcname": "ImParseFormatTrimDecorations",
+      "location": "imgui_internal:402",
+      "ov_cimguiname": "igImParseFormatTrimDecorations",
+      "ret": "const char*",
+      "signature": "(const char*,char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igImPow": [
+    {
+      "args": "(float x,float y)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        },
+        {
+          "name": "y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x,float y)",
+      "call_args": "(x,y)",
+      "cimguiname": "igImPow",
+      "defaults": {},
+      "funcname": "ImPow",
+      "location": "imgui_internal:453",
+      "ov_cimguiname": "igImPow_Float",
+      "ret": "float",
+      "signature": "(float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x,double y)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x,double y)",
+      "call_args": "(x,y)",
+      "cimguiname": "igImPow",
+      "defaults": {},
+      "funcname": "ImPow",
+      "location": "imgui_internal:454",
+      "ov_cimguiname": "igImPow_double",
+      "ret": "double",
+      "signature": "(double,double)",
+      "stname": ""
+    }
+  ],
+  "igImQsort": [
+    {
+      "args": "(void* base,size_t count,size_t size_of_element,int(*compare_func)(void const*,void const*))",
+      "argsT": [
+        {
+          "name": "base",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "size_t"
+        },
+        {
+          "name": "size_of_element",
+          "type": "size_t"
+        },
+        {
+          "name": "compare_func",
+          "ret": "int",
+          "signature": "(void const*,void const*)",
+          "type": "int(*)(void const*,void const*)"
+        }
+      ],
+      "argsoriginal": "(void* base,size_t count,size_t size_of_element,int(*compare_func)(void const*,void const*))",
+      "call_args": "(base,count,size_of_element,compare_func)",
+      "cimguiname": "igImQsort",
+      "defaults": {},
+      "funcname": "ImQsort",
+      "location": "imgui_internal:364",
+      "ov_cimguiname": "igImQsort",
+      "ret": "void",
+      "signature": "(void*,size_t,size_t,int(*)(void const*,void const*))",
+      "stname": ""
+    }
+  ],
+  "igImRotate": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 v,float cos_a,float sin_a)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "v",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cos_a",
+          "type": "float"
+        },
+        {
+          "name": "sin_a",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& v,float cos_a,float sin_a)",
+      "call_args": "(v,cos_a,sin_a)",
+      "cimguiname": "igImRotate",
+      "defaults": {},
+      "funcname": "ImRotate",
+      "location": "imgui_internal:495",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImRotate",
+      "ret": "void",
+      "signature": "(const ImVec2,float,float)",
+      "stname": ""
+    }
+  ],
+  "igImRsqrt": [
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "igImRsqrt",
+      "defaults": {},
+      "funcname": "ImRsqrt",
+      "location": "imgui_internal:465",
+      "ov_cimguiname": "igImRsqrt_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "igImRsqrt",
+      "defaults": {},
+      "funcname": "ImRsqrt",
+      "location": "imgui_internal:467",
+      "ov_cimguiname": "igImRsqrt_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "igImSaturate": [
+    {
+      "args": "(float f)",
+      "argsT": [
+        {
+          "name": "f",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float f)",
+      "call_args": "(f)",
+      "cimguiname": "igImSaturate",
+      "defaults": {},
+      "funcname": "ImSaturate",
+      "location": "imgui_internal:485",
+      "ov_cimguiname": "igImSaturate",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igImSign": [
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "igImSign",
+      "defaults": {},
+      "funcname": "ImSign",
+      "location": "imgui_internal:460",
+      "ov_cimguiname": "igImSign_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "igImSign",
+      "defaults": {},
+      "funcname": "ImSign",
+      "location": "imgui_internal:461",
+      "ov_cimguiname": "igImSign_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "igImStrSkipBlank": [
+    {
+      "args": "(const char* str)",
+      "argsT": [
+        {
+          "name": "str",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str)",
+      "call_args": "(str)",
+      "cimguiname": "igImStrSkipBlank",
+      "defaults": {},
+      "funcname": "ImStrSkipBlank",
+      "location": "imgui_internal:385",
+      "ov_cimguiname": "igImStrSkipBlank",
+      "ret": "const char*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStrTrimBlanks": [
+    {
+      "args": "(char* str)",
+      "argsT": [
+        {
+          "name": "str",
+          "type": "char*"
+        }
+      ],
+      "argsoriginal": "(char* str)",
+      "call_args": "(str)",
+      "cimguiname": "igImStrTrimBlanks",
+      "defaults": {},
+      "funcname": "ImStrTrimBlanks",
+      "location": "imgui_internal:384",
+      "ov_cimguiname": "igImStrTrimBlanks",
+      "ret": "void",
+      "signature": "(char*)",
+      "stname": ""
+    }
+  ],
+  "igImStrbol": [
+    {
+      "args": "(const char* buf_mid_line,const char* buf_begin)",
+      "argsT": [
+        {
+          "name": "buf_mid_line",
+          "type": "const char*"
+        },
+        {
+          "name": "buf_begin",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* buf_mid_line,const char* buf_begin)",
+      "call_args": "(buf_mid_line,buf_begin)",
+      "cimguiname": "igImStrbol",
+      "defaults": {},
+      "funcname": "ImStrbol",
+      "location": "imgui_internal:387",
+      "ov_cimguiname": "igImStrbol",
+      "ret": "const char*",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStrchrRange": [
+    {
+      "args": "(const char* str_begin,const char* str_end,char c)",
+      "argsT": [
+        {
+          "name": "str_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "str_end",
+          "type": "const char*"
+        },
+        {
+          "name": "c",
+          "type": "char"
+        }
+      ],
+      "argsoriginal": "(const char* str_begin,const char* str_end,char c)",
+      "call_args": "(str_begin,str_end,c)",
+      "cimguiname": "igImStrchrRange",
+      "defaults": {},
+      "funcname": "ImStrchrRange",
+      "location": "imgui_internal:381",
+      "ov_cimguiname": "igImStrchrRange",
+      "ret": "const char*",
+      "signature": "(const char*,const char*,char)",
+      "stname": ""
+    }
+  ],
+  "igImStrdup": [
+    {
+      "args": "(const char* str)",
+      "argsT": [
+        {
+          "name": "str",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str)",
+      "call_args": "(str)",
+      "cimguiname": "igImStrdup",
+      "defaults": {},
+      "funcname": "ImStrdup",
+      "location": "imgui_internal:379",
+      "ov_cimguiname": "igImStrdup",
+      "ret": "char*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStrdupcpy": [
+    {
+      "args": "(char* dst,size_t* p_dst_size,const char* str)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "char*"
+        },
+        {
+          "name": "p_dst_size",
+          "type": "size_t*"
+        },
+        {
+          "name": "str",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(char* dst,size_t* p_dst_size,const char* str)",
+      "call_args": "(dst,p_dst_size,str)",
+      "cimguiname": "igImStrdupcpy",
+      "defaults": {},
+      "funcname": "ImStrdupcpy",
+      "location": "imgui_internal:380",
+      "ov_cimguiname": "igImStrdupcpy",
+      "ret": "char*",
+      "signature": "(char*,size_t*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStreolRange": [
+    {
+      "args": "(const char* str,const char* str_end)",
+      "argsT": [
+        {
+          "name": "str",
+          "type": "const char*"
+        },
+        {
+          "name": "str_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str,const char* str_end)",
+      "call_args": "(str,str_end)",
+      "cimguiname": "igImStreolRange",
+      "defaults": {},
+      "funcname": "ImStreolRange",
+      "location": "imgui_internal:382",
+      "ov_cimguiname": "igImStreolRange",
+      "ret": "const char*",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStricmp": [
+    {
+      "args": "(const char* str1,const char* str2)",
+      "argsT": [
+        {
+          "name": "str1",
+          "type": "const char*"
+        },
+        {
+          "name": "str2",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str1,const char* str2)",
+      "call_args": "(str1,str2)",
+      "cimguiname": "igImStricmp",
+      "defaults": {},
+      "funcname": "ImStricmp",
+      "location": "imgui_internal:376",
+      "ov_cimguiname": "igImStricmp",
+      "ret": "int",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStristr": [
+    {
+      "args": "(const char* haystack,const char* haystack_end,const char* needle,const char* needle_end)",
+      "argsT": [
+        {
+          "name": "haystack",
+          "type": "const char*"
+        },
+        {
+          "name": "haystack_end",
+          "type": "const char*"
+        },
+        {
+          "name": "needle",
+          "type": "const char*"
+        },
+        {
+          "name": "needle_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* haystack,const char* haystack_end,const char* needle,const char* needle_end)",
+      "call_args": "(haystack,haystack_end,needle,needle_end)",
+      "cimguiname": "igImStristr",
+      "defaults": {},
+      "funcname": "ImStristr",
+      "location": "imgui_internal:383",
+      "ov_cimguiname": "igImStristr",
+      "ret": "const char*",
+      "signature": "(const char*,const char*,const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImStrlenW": [
+    {
+      "args": "(const ImWchar* str)",
+      "argsT": [
+        {
+          "name": "str",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(const ImWchar* str)",
+      "call_args": "(str)",
+      "cimguiname": "igImStrlenW",
+      "defaults": {},
+      "funcname": "ImStrlenW",
+      "location": "imgui_internal:386",
+      "ov_cimguiname": "igImStrlenW",
+      "ret": "int",
+      "signature": "(const ImWchar*)",
+      "stname": ""
+    }
+  ],
+  "igImStrncpy": [
+    {
+      "args": "(char* dst,const char* src,size_t count)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "char*"
+        },
+        {
+          "name": "src",
+          "type": "const char*"
+        },
+        {
+          "name": "count",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(char* dst,const char* src,size_t count)",
+      "call_args": "(dst,src,count)",
+      "cimguiname": "igImStrncpy",
+      "defaults": {},
+      "funcname": "ImStrncpy",
+      "location": "imgui_internal:378",
+      "ov_cimguiname": "igImStrncpy",
+      "ret": "void",
+      "signature": "(char*,const char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igImStrnicmp": [
+    {
+      "args": "(const char* str1,const char* str2,size_t count)",
+      "argsT": [
+        {
+          "name": "str1",
+          "type": "const char*"
+        },
+        {
+          "name": "str2",
+          "type": "const char*"
+        },
+        {
+          "name": "count",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* str1,const char* str2,size_t count)",
+      "call_args": "(str1,str2,count)",
+      "cimguiname": "igImStrnicmp",
+      "defaults": {},
+      "funcname": "ImStrnicmp",
+      "location": "imgui_internal:377",
+      "ov_cimguiname": "igImStrnicmp",
+      "ret": "int",
+      "signature": "(const char*,const char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igImTextCharFromUtf8": [
+    {
+      "args": "(unsigned int* out_char,const char* in_text,const char* in_text_end)",
+      "argsT": [
+        {
+          "name": "out_char",
+          "type": "unsigned int*"
+        },
+        {
+          "name": "in_text",
+          "type": "const char*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(unsigned int* out_char,const char* in_text,const char* in_text_end)",
+      "call_args": "(out_char,in_text,in_text_end)",
+      "cimguiname": "igImTextCharFromUtf8",
+      "defaults": {},
+      "funcname": "ImTextCharFromUtf8",
+      "location": "imgui_internal:410",
+      "ov_cimguiname": "igImTextCharFromUtf8",
+      "ret": "int",
+      "signature": "(unsigned int*,const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImTextCharToUtf8": [
+    {
+      "args": "(char out_buf[5],unsigned int c)",
+      "argsT": [
+        {
+          "name": "out_buf",
+          "type": "char[5]"
+        },
+        {
+          "name": "c",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(char out_buf[5],unsigned int c)",
+      "call_args": "(out_buf,c)",
+      "cimguiname": "igImTextCharToUtf8",
+      "defaults": {},
+      "funcname": "ImTextCharToUtf8",
+      "location": "imgui_internal:408",
+      "ov_cimguiname": "igImTextCharToUtf8",
+      "ret": "const char*",
+      "signature": "(char[5],unsigned int)",
+      "stname": ""
+    }
+  ],
+  "igImTextCountCharsFromUtf8": [
+    {
+      "args": "(const char* in_text,const char* in_text_end)",
+      "argsT": [
+        {
+          "name": "in_text",
+          "type": "const char*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* in_text,const char* in_text_end)",
+      "call_args": "(in_text,in_text_end)",
+      "cimguiname": "igImTextCountCharsFromUtf8",
+      "defaults": {},
+      "funcname": "ImTextCountCharsFromUtf8",
+      "location": "imgui_internal:412",
+      "ov_cimguiname": "igImTextCountCharsFromUtf8",
+      "ret": "int",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImTextCountLines": [
+    {
+      "args": "(const char* in_text,const char* in_text_end)",
+      "argsT": [
+        {
+          "name": "in_text",
+          "type": "const char*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* in_text,const char* in_text_end)",
+      "call_args": "(in_text,in_text_end)",
+      "cimguiname": "igImTextCountLines",
+      "defaults": {},
+      "funcname": "ImTextCountLines",
+      "location": "imgui_internal:416",
+      "ov_cimguiname": "igImTextCountLines",
+      "ret": "int",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImTextCountUtf8BytesFromChar": [
+    {
+      "args": "(const char* in_text,const char* in_text_end)",
+      "argsT": [
+        {
+          "name": "in_text",
+          "type": "const char*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* in_text,const char* in_text_end)",
+      "call_args": "(in_text,in_text_end)",
+      "cimguiname": "igImTextCountUtf8BytesFromChar",
+      "defaults": {},
+      "funcname": "ImTextCountUtf8BytesFromChar",
+      "location": "imgui_internal:413",
+      "ov_cimguiname": "igImTextCountUtf8BytesFromChar",
+      "ret": "int",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImTextCountUtf8BytesFromStr": [
+    {
+      "args": "(const ImWchar* in_text,const ImWchar* in_text_end)",
+      "argsT": [
+        {
+          "name": "in_text",
+          "type": "const ImWchar*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(const ImWchar* in_text,const ImWchar* in_text_end)",
+      "call_args": "(in_text,in_text_end)",
+      "cimguiname": "igImTextCountUtf8BytesFromStr",
+      "defaults": {},
+      "funcname": "ImTextCountUtf8BytesFromStr",
+      "location": "imgui_internal:414",
+      "ov_cimguiname": "igImTextCountUtf8BytesFromStr",
+      "ret": "int",
+      "signature": "(const ImWchar*,const ImWchar*)",
+      "stname": ""
+    }
+  ],
+  "igImTextFindPreviousUtf8Codepoint": [
+    {
+      "args": "(const char* in_text_start,const char* in_text_curr)",
+      "argsT": [
+        {
+          "name": "in_text_start",
+          "type": "const char*"
+        },
+        {
+          "name": "in_text_curr",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* in_text_start,const char* in_text_curr)",
+      "call_args": "(in_text_start,in_text_curr)",
+      "cimguiname": "igImTextFindPreviousUtf8Codepoint",
+      "defaults": {},
+      "funcname": "ImTextFindPreviousUtf8Codepoint",
+      "location": "imgui_internal:415",
+      "ov_cimguiname": "igImTextFindPreviousUtf8Codepoint",
+      "ret": "const char*",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igImTextStrFromUtf8": [
+    {
+      "args": "(ImWchar* out_buf,int out_buf_size,const char* in_text,const char* in_text_end,const char** in_remaining)",
+      "argsT": [
+        {
+          "name": "out_buf",
+          "type": "ImWchar*"
+        },
+        {
+          "name": "out_buf_size",
+          "type": "int"
+        },
+        {
+          "name": "in_text",
+          "type": "const char*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "in_remaining",
+          "type": "const char**"
+        }
+      ],
+      "argsoriginal": "(ImWchar* out_buf,int out_buf_size,const char* in_text,const char* in_text_end,const char** in_remaining=((void*)0))",
+      "call_args": "(out_buf,out_buf_size,in_text,in_text_end,in_remaining)",
+      "cimguiname": "igImTextStrFromUtf8",
+      "defaults": {
+        "in_remaining": "NULL"
+      },
+      "funcname": "ImTextStrFromUtf8",
+      "location": "imgui_internal:411",
+      "ov_cimguiname": "igImTextStrFromUtf8",
+      "ret": "int",
+      "signature": "(ImWchar*,int,const char*,const char*,const char**)",
+      "stname": ""
+    }
+  ],
+  "igImTextStrToUtf8": [
+    {
+      "args": "(char* out_buf,int out_buf_size,const ImWchar* in_text,const ImWchar* in_text_end)",
+      "argsT": [
+        {
+          "name": "out_buf",
+          "type": "char*"
+        },
+        {
+          "name": "out_buf_size",
+          "type": "int"
+        },
+        {
+          "name": "in_text",
+          "type": "const ImWchar*"
+        },
+        {
+          "name": "in_text_end",
+          "type": "const ImWchar*"
+        }
+      ],
+      "argsoriginal": "(char* out_buf,int out_buf_size,const ImWchar* in_text,const ImWchar* in_text_end)",
+      "call_args": "(out_buf,out_buf_size,in_text,in_text_end)",
+      "cimguiname": "igImTextStrToUtf8",
+      "defaults": {},
+      "funcname": "ImTextStrToUtf8",
+      "location": "imgui_internal:409",
+      "ov_cimguiname": "igImTextStrToUtf8",
+      "ret": "int",
+      "signature": "(char*,int,const ImWchar*,const ImWchar*)",
+      "stname": ""
+    }
+  ],
+  "igImToUpper": [
+    {
+      "args": "(char c)",
+      "argsT": [
+        {
+          "name": "c",
+          "type": "char"
+        }
+      ],
+      "argsoriginal": "(char c)",
+      "call_args": "(c)",
+      "cimguiname": "igImToUpper",
+      "defaults": {},
+      "funcname": "ImToUpper",
+      "location": "imgui_internal:389",
+      "ov_cimguiname": "igImToUpper",
+      "ret": "char",
+      "signature": "(char)",
+      "stname": ""
+    }
+  ],
+  "igImTriangleArea": [
+    {
+      "args": "(const ImVec2 a,const ImVec2 b,const ImVec2 c)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "c",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c)",
+      "call_args": "(a,b,c)",
+      "cimguiname": "igImTriangleArea",
+      "defaults": {},
+      "funcname": "ImTriangleArea",
+      "location": "imgui_internal:512",
+      "ov_cimguiname": "igImTriangleArea",
+      "ret": "float",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImTriangleBarycentricCoords": [
+    {
+      "args": "(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "c",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "out_u",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "out_v",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "out_w",
+          "reftoptr": true,
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& p,float& out_u,float& out_v,float& out_w)",
+      "call_args": "(a,b,c,p,*out_u,*out_v,*out_w)",
+      "cimguiname": "igImTriangleBarycentricCoords",
+      "defaults": {},
+      "funcname": "ImTriangleBarycentricCoords",
+      "location": "imgui_internal:511",
+      "ov_cimguiname": "igImTriangleBarycentricCoords",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2,float*,float*,float*)",
+      "stname": ""
+    }
+  ],
+  "igImTriangleClosestPoint": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "c",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& p)",
+      "call_args": "(a,b,c,p)",
+      "cimguiname": "igImTriangleClosestPoint",
+      "defaults": {},
+      "funcname": "ImTriangleClosestPoint",
+      "location": "imgui_internal:510",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImTriangleClosestPoint",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImTriangleContainsPoint": [
+    {
+      "args": "(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "c",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c,const ImVec2& p)",
+      "call_args": "(a,b,c,p)",
+      "cimguiname": "igImTriangleContainsPoint",
+      "defaults": {},
+      "funcname": "ImTriangleContainsPoint",
+      "location": "imgui_internal:509",
+      "ov_cimguiname": "igImTriangleContainsPoint",
+      "ret": "bool",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImTriangleIsClockwise": [
+    {
+      "args": "(const ImVec2 a,const ImVec2 b,const ImVec2 c)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "c",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a,const ImVec2& b,const ImVec2& c)",
+      "call_args": "(a,b,c)",
+      "cimguiname": "igImTriangleIsClockwise",
+      "defaults": {},
+      "funcname": "ImTriangleIsClockwise",
+      "location": "imgui_internal:513",
+      "ov_cimguiname": "igImTriangleIsClockwise",
+      "ret": "bool",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImTrunc": [
+    {
+      "args": "(float f)",
+      "argsT": [
+        {
+          "name": "f",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float f)",
+      "call_args": "(f)",
+      "cimguiname": "igImTrunc",
+      "defaults": {},
+      "funcname": "ImTrunc",
+      "location": "imgui_internal:489",
+      "ov_cimguiname": "igImTrunc_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 v)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "v",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& v)",
+      "call_args": "(v)",
+      "cimguiname": "igImTrunc",
+      "defaults": {},
+      "funcname": "ImTrunc",
+      "location": "imgui_internal:490",
+      "nonUDT": 1,
+      "ov_cimguiname": "igImTrunc_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igImUpperPowerOfTwo": [
+    {
+      "args": "(int v)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int v)",
+      "call_args": "(v)",
+      "cimguiname": "igImUpperPowerOfTwo",
+      "defaults": {},
+      "funcname": "ImUpperPowerOfTwo",
+      "location": "imgui_internal:373",
+      "ov_cimguiname": "igImUpperPowerOfTwo",
+      "ret": "int",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igImage": [
+    {
+      "args": "(ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col)",
+      "argsT": [
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "image_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv0",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "tint_col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "border_col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(ImTextureID user_texture_id,const ImVec2& image_size,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),const ImVec4& tint_col=ImVec4(1,1,1,1),const ImVec4& border_col=ImVec4(0,0,0,0))",
+      "call_args": "(user_texture_id,image_size,uv0,uv1,tint_col,border_col)",
+      "cimguiname": "igImage",
+      "defaults": {
+        "border_col": "ImVec4(0,0,0,0)",
+        "tint_col": "ImVec4(1,1,1,1)",
+        "uv0": "ImVec2(0,0)",
+        "uv1": "ImVec2(1,1)"
+      },
+      "funcname": "Image",
+      "location": "imgui:576",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igImage",
+      "ret": "void",
+      "signature": "(ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec4,const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "igImageButton": [
+    {
+      "args": "(const char* str_id,ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "image_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv0",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "bg_col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "tint_col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImTextureID user_texture_id,const ImVec2& image_size,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),const ImVec4& bg_col=ImVec4(0,0,0,0),const ImVec4& tint_col=ImVec4(1,1,1,1))",
+      "call_args": "(str_id,user_texture_id,image_size,uv0,uv1,bg_col,tint_col)",
+      "cimguiname": "igImageButton",
+      "defaults": {
+        "bg_col": "ImVec4(0,0,0,0)",
+        "tint_col": "ImVec4(1,1,1,1)",
+        "uv0": "ImVec2(0,0)",
+        "uv1": "ImVec2(1,1)"
+      },
+      "funcname": "ImageButton",
+      "location": "imgui:577",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igImageButton",
+      "ret": "bool",
+      "signature": "(const char*,ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec4,const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "igImageButtonEx": [
+    {
+      "args": "(ImGuiID id,ImTextureID user_texture_id,const ImVec2 image_size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 bg_col,const ImVec4 tint_col,ImGuiButtonFlags flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "image_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv0",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "bg_col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "tint_col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiButtonFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImTextureID user_texture_id,const ImVec2& image_size,const ImVec2& uv0,const ImVec2& uv1,const ImVec4& bg_col,const ImVec4& tint_col,ImGuiButtonFlags flags=0)",
+      "call_args": "(id,user_texture_id,image_size,uv0,uv1,bg_col,tint_col,flags)",
+      "cimguiname": "igImageButtonEx",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ImageButtonEx",
+      "location": "imgui_internal:3695",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igImageButtonEx",
+      "ret": "bool",
+      "signature": "(ImGuiID,ImTextureID,const ImVec2,const ImVec2,const ImVec2,const ImVec4,const ImVec4,ImGuiButtonFlags)",
+      "stname": ""
+    }
+  ],
+  "igIndent": [
+    {
+      "args": "(float indent_w)",
+      "argsT": [
+        {
+          "name": "indent_w",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float indent_w=0.0f)",
+      "call_args": "(indent_w)",
+      "cimguiname": "igIndent",
+      "defaults": {
+        "indent_w": "0.0f"
+      },
+      "funcname": "Indent",
+      "location": "imgui:507",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIndent",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igInitialize": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igInitialize",
+      "defaults": {},
+      "funcname": "Initialize",
+      "location": "imgui_internal:3239",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInitialize",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igInputDouble": [
+    {
+      "args": "(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "double*"
+        },
+        {
+          "name": "step",
+          "type": "double"
+        },
+        {
+          "name": "step_fast",
+          "type": "double"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,double* v,double step=0.0,double step_fast=0.0,const char* format=\"%.6f\",ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,step,step_fast,format,flags)",
+      "cimguiname": "igInputDouble",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.6f\"",
+        "step": "0.0",
+        "step_fast": "0.0"
+      },
+      "funcname": "InputDouble",
+      "location": "imgui:648",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputDouble",
+      "ret": "bool",
+      "signature": "(const char*,double*,double,double,const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputFloat": [
+    {
+      "args": "(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float*"
+        },
+        {
+          "name": "step",
+          "type": "float"
+        },
+        {
+          "name": "step_fast",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float* v,float step=0.0f,float step_fast=0.0f,const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,step,step_fast,format,flags)",
+      "cimguiname": "igInputFloat",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\"",
+        "step": "0.0f",
+        "step_fast": "0.0f"
+      },
+      "funcname": "InputFloat",
+      "location": "imgui:640",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputFloat",
+      "ret": "bool",
+      "signature": "(const char*,float*,float,float,const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputFloat2": [
+    {
+      "args": "(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[2]"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[2],const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,format,flags)",
+      "cimguiname": "igInputFloat2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "InputFloat2",
+      "location": "imgui:641",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputFloat2",
+      "ret": "bool",
+      "signature": "(const char*,float[2],const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputFloat3": [
+    {
+      "args": "(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[3]"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[3],const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,format,flags)",
+      "cimguiname": "igInputFloat3",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "InputFloat3",
+      "location": "imgui:642",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputFloat3",
+      "ret": "bool",
+      "signature": "(const char*,float[3],const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputFloat4": [
+    {
+      "args": "(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[4]"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[4],const char* format=\"%.3f\",ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,format,flags)",
+      "cimguiname": "igInputFloat4",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "InputFloat4",
+      "location": "imgui:643",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputFloat4",
+      "ret": "bool",
+      "signature": "(const char*,float[4],const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputInt": [
+    {
+      "args": "(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int*"
+        },
+        {
+          "name": "step",
+          "type": "int"
+        },
+        {
+          "name": "step_fast",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* v,int step=1,int step_fast=100,ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,step,step_fast,flags)",
+      "cimguiname": "igInputInt",
+      "defaults": {
+        "flags": "0",
+        "step": "1",
+        "step_fast": "100"
+      },
+      "funcname": "InputInt",
+      "location": "imgui:644",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputInt",
+      "ret": "bool",
+      "signature": "(const char*,int*,int,int,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputInt2": [
+    {
+      "args": "(const char* label,int v[2],ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[2]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[2],ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,flags)",
+      "cimguiname": "igInputInt2",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "InputInt2",
+      "location": "imgui:645",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputInt2",
+      "ret": "bool",
+      "signature": "(const char*,int[2],ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputInt3": [
+    {
+      "args": "(const char* label,int v[3],ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[3]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[3],ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,flags)",
+      "cimguiname": "igInputInt3",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "InputInt3",
+      "location": "imgui:646",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputInt3",
+      "ret": "bool",
+      "signature": "(const char*,int[3],ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputInt4": [
+    {
+      "args": "(const char* label,int v[4],ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[4]"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[4],ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,v,flags)",
+      "cimguiname": "igInputInt4",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "InputInt4",
+      "location": "imgui:647",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputInt4",
+      "ret": "bool",
+      "signature": "(const char*,int[4],ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputScalar": [
+    {
+      "args": "(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "p_step",
+          "type": "const void*"
+        },
+        {
+          "name": "p_step_fast",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* p_data,const void* p_step=((void*)0),const void* p_step_fast=((void*)0),const char* format=((void*)0),ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,data_type,p_data,p_step,p_step_fast,format,flags)",
+      "cimguiname": "igInputScalar",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL",
+        "p_step": "NULL",
+        "p_step_fast": "NULL"
+      },
+      "funcname": "InputScalar",
+      "location": "imgui:649",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputScalar",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,const void*,const void*,const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputScalarN": [
+    {
+      "args": "(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step,const void* p_step_fast,const char* format,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "components",
+          "type": "int"
+        },
+        {
+          "name": "p_step",
+          "type": "const void*"
+        },
+        {
+          "name": "p_step_fast",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_step=((void*)0),const void* p_step_fast=((void*)0),const char* format=((void*)0),ImGuiInputTextFlags flags=0)",
+      "call_args": "(label,data_type,p_data,components,p_step,p_step_fast,format,flags)",
+      "cimguiname": "igInputScalarN",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL",
+        "p_step": "NULL",
+        "p_step_fast": "NULL"
+      },
+      "funcname": "InputScalarN",
+      "location": "imgui:650",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputScalarN",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,int,const void*,const void*,const char*,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igInputText": [
+    {
+      "args": "(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "size_t"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        },
+        {
+          "name": "callback",
+          "type": "ImGuiInputTextCallback"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags=0,ImGuiInputTextCallback callback=((void*)0),void* user_data=((void*)0))",
+      "call_args": "(label,buf,buf_size,flags,callback,user_data)",
+      "cimguiname": "igInputText",
+      "defaults": {
+        "callback": "NULL",
+        "flags": "0",
+        "user_data": "NULL"
+      },
+      "funcname": "InputText",
+      "location": "imgui:637",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputText",
+      "ret": "bool",
+      "signature": "(const char*,char*,size_t,ImGuiInputTextFlags,ImGuiInputTextCallback,void*)",
+      "stname": ""
+    }
+  ],
+  "igInputTextDeactivateHook": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igInputTextDeactivateHook",
+      "defaults": {},
+      "funcname": "InputTextDeactivateHook",
+      "location": "imgui_internal:3745",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputTextDeactivateHook",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igInputTextEx": [
+    {
+      "args": "(const char* label,const char* hint,char* buf,int buf_size,const ImVec2 size_arg,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "hint",
+          "type": "const char*"
+        },
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "int"
+        },
+        {
+          "name": "size_arg",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        },
+        {
+          "name": "callback",
+          "type": "ImGuiInputTextCallback"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* hint,char* buf,int buf_size,const ImVec2& size_arg,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback=((void*)0),void* user_data=((void*)0))",
+      "call_args": "(label,hint,buf,buf_size,size_arg,flags,callback,user_data)",
+      "cimguiname": "igInputTextEx",
+      "defaults": {
+        "callback": "NULL",
+        "user_data": "NULL"
+      },
+      "funcname": "InputTextEx",
+      "location": "imgui_internal:3744",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputTextEx",
+      "ret": "bool",
+      "signature": "(const char*,const char*,char*,int,const ImVec2,ImGuiInputTextFlags,ImGuiInputTextCallback,void*)",
+      "stname": ""
+    }
+  ],
+  "igInputTextMultiline": [
+    {
+      "args": "(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "size_t"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        },
+        {
+          "name": "callback",
+          "type": "ImGuiInputTextCallback"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(const char* label,char* buf,size_t buf_size,const ImVec2& size=ImVec2(0,0),ImGuiInputTextFlags flags=0,ImGuiInputTextCallback callback=((void*)0),void* user_data=((void*)0))",
+      "call_args": "(label,buf,buf_size,size,flags,callback,user_data)",
+      "cimguiname": "igInputTextMultiline",
+      "defaults": {
+        "callback": "NULL",
+        "flags": "0",
+        "size": "ImVec2(0,0)",
+        "user_data": "NULL"
+      },
+      "funcname": "InputTextMultiline",
+      "location": "imgui:638",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputTextMultiline",
+      "ret": "bool",
+      "signature": "(const char*,char*,size_t,const ImVec2,ImGuiInputTextFlags,ImGuiInputTextCallback,void*)",
+      "stname": ""
+    }
+  ],
+  "igInputTextWithHint": [
+    {
+      "args": "(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "hint",
+          "type": "const char*"
+        },
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "size_t"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        },
+        {
+          "name": "callback",
+          "type": "ImGuiInputTextCallback"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags=0,ImGuiInputTextCallback callback=((void*)0),void* user_data=((void*)0))",
+      "call_args": "(label,hint,buf,buf_size,flags,callback,user_data)",
+      "cimguiname": "igInputTextWithHint",
+      "defaults": {
+        "callback": "NULL",
+        "flags": "0",
+        "user_data": "NULL"
+      },
+      "funcname": "InputTextWithHint",
+      "location": "imgui:639",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInputTextWithHint",
+      "ret": "bool",
+      "signature": "(const char*,const char*,char*,size_t,ImGuiInputTextFlags,ImGuiInputTextCallback,void*)",
+      "stname": ""
+    }
+  ],
+  "igInvisibleButton": [
+    {
+      "args": "(const char* str_id,const ImVec2 size,ImGuiButtonFlags flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiButtonFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,const ImVec2& size,ImGuiButtonFlags flags=0)",
+      "call_args": "(str_id,size,flags)",
+      "cimguiname": "igInvisibleButton",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "InvisibleButton",
+      "location": "imgui:559",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igInvisibleButton",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,ImGuiButtonFlags)",
+      "stname": ""
+    }
+  ],
+  "igIsActiveIdUsingNavDir": [
+    {
+      "args": "(ImGuiDir dir)",
+      "argsT": [
+        {
+          "name": "dir",
+          "type": "ImGuiDir"
+        }
+      ],
+      "argsoriginal": "(ImGuiDir dir)",
+      "call_args": "(dir)",
+      "cimguiname": "igIsActiveIdUsingNavDir",
+      "defaults": {},
+      "funcname": "IsActiveIdUsingNavDir",
+      "location": "imgui_internal:3424",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsActiveIdUsingNavDir",
+      "ret": "bool",
+      "signature": "(ImGuiDir)",
+      "stname": ""
+    }
+  ],
+  "igIsAliasKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsAliasKey",
+      "defaults": {},
+      "funcname": "IsAliasKey",
+      "location": "imgui_internal:3401",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsAliasKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsAnyItemActive": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsAnyItemActive",
+      "defaults": {},
+      "funcname": "IsAnyItemActive",
+      "location": "imgui:956",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsAnyItemActive",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsAnyItemFocused": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsAnyItemFocused",
+      "defaults": {},
+      "funcname": "IsAnyItemFocused",
+      "location": "imgui:957",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsAnyItemFocused",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsAnyItemHovered": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsAnyItemHovered",
+      "defaults": {},
+      "funcname": "IsAnyItemHovered",
+      "location": "imgui:955",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsAnyItemHovered",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsAnyMouseDown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsAnyMouseDown",
+      "defaults": {},
+      "funcname": "IsAnyMouseDown",
+      "location": "imgui:1041",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsAnyMouseDown",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsClippedEx": [
+    {
+      "args": "(const ImRect bb,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id)",
+      "call_args": "(bb,id)",
+      "cimguiname": "igIsClippedEx",
+      "defaults": {},
+      "funcname": "IsClippedEx",
+      "location": "imgui_internal:3319",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsClippedEx",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsDragDropActive": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsDragDropActive",
+      "defaults": {},
+      "funcname": "IsDragDropActive",
+      "location": "imgui_internal:3546",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsDragDropActive",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsDragDropPayloadBeingAccepted": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsDragDropPayloadBeingAccepted",
+      "defaults": {},
+      "funcname": "IsDragDropPayloadBeingAccepted",
+      "location": "imgui_internal:3549",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsDragDropPayloadBeingAccepted",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsGamepadKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsGamepadKey",
+      "defaults": {},
+      "funcname": "IsGamepadKey",
+      "location": "imgui_internal:3399",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsGamepadKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsItemActivated": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemActivated",
+      "defaults": {},
+      "funcname": "IsItemActivated",
+      "location": "imgui:951",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemActivated",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemActive": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemActive",
+      "defaults": {},
+      "funcname": "IsItemActive",
+      "location": "imgui:946",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemActive",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemClicked": [
+    {
+      "args": "(ImGuiMouseButton mouse_button)",
+      "argsT": [
+        {
+          "name": "mouse_button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton mouse_button=0)",
+      "call_args": "(mouse_button)",
+      "cimguiname": "igIsItemClicked",
+      "defaults": {
+        "mouse_button": "0"
+      },
+      "funcname": "IsItemClicked",
+      "location": "imgui:948",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemClicked",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    }
+  ],
+  "igIsItemDeactivated": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemDeactivated",
+      "defaults": {},
+      "funcname": "IsItemDeactivated",
+      "location": "imgui:952",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemDeactivated",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemDeactivatedAfterEdit": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemDeactivatedAfterEdit",
+      "defaults": {},
+      "funcname": "IsItemDeactivatedAfterEdit",
+      "location": "imgui:953",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemDeactivatedAfterEdit",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemEdited": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemEdited",
+      "defaults": {},
+      "funcname": "IsItemEdited",
+      "location": "imgui:950",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemEdited",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemFocused": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemFocused",
+      "defaults": {},
+      "funcname": "IsItemFocused",
+      "location": "imgui:947",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemFocused",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemHovered": [
+    {
+      "args": "(ImGuiHoveredFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiHoveredFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiHoveredFlags flags=0)",
+      "call_args": "(flags)",
+      "cimguiname": "igIsItemHovered",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "IsItemHovered",
+      "location": "imgui:945",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemHovered",
+      "ret": "bool",
+      "signature": "(ImGuiHoveredFlags)",
+      "stname": ""
+    }
+  ],
+  "igIsItemToggledOpen": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemToggledOpen",
+      "defaults": {},
+      "funcname": "IsItemToggledOpen",
+      "location": "imgui:954",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemToggledOpen",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemToggledSelection": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemToggledSelection",
+      "defaults": {},
+      "funcname": "IsItemToggledSelection",
+      "location": "imgui:699",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemToggledSelection",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsItemVisible": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsItemVisible",
+      "defaults": {},
+      "funcname": "IsItemVisible",
+      "location": "imgui:949",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsItemVisible",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsKeyChordPressed": [
+    {
+      "args": "(ImGuiKeyChord key_chord)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord)",
+      "call_args": "(key_chord)",
+      "cimguiname": "igIsKeyChordPressed",
+      "defaults": {},
+      "funcname": "IsKeyChordPressed",
+      "location": "imgui:999",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyChordPressed_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiKeyChord)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id=0)",
+      "call_args": "(key_chord,flags,owner_id)",
+      "cimguiname": "igIsKeyChordPressed",
+      "defaults": {
+        "owner_id": "0"
+      },
+      "funcname": "IsKeyChordPressed",
+      "location": "imgui_internal:3453",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyChordPressed_InputFlags",
+      "ret": "bool",
+      "signature": "(ImGuiKeyChord,ImGuiInputFlags,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsKeyDown": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsKeyDown",
+      "defaults": {},
+      "funcname": "IsKeyDown",
+      "location": "imgui:996",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyDown_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKey key,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,ImGuiID owner_id)",
+      "call_args": "(key,owner_id)",
+      "cimguiname": "igIsKeyDown",
+      "defaults": {},
+      "funcname": "IsKeyDown",
+      "location": "imgui_internal:3450",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyDown_ID",
+      "ret": "bool",
+      "signature": "(ImGuiKey,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsKeyPressed": [
+    {
+      "args": "(ImGuiKey key,bool repeat)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "repeat",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,bool repeat=true)",
+      "call_args": "(key,repeat)",
+      "cimguiname": "igIsKeyPressed",
+      "defaults": {
+        "repeat": "true"
+      },
+      "funcname": "IsKeyPressed",
+      "location": "imgui:997",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyPressed_Bool",
+      "ret": "bool",
+      "signature": "(ImGuiKey,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKey key,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,ImGuiInputFlags flags,ImGuiID owner_id=0)",
+      "call_args": "(key,flags,owner_id)",
+      "cimguiname": "igIsKeyPressed",
+      "defaults": {
+        "owner_id": "0"
+      },
+      "funcname": "IsKeyPressed",
+      "location": "imgui_internal:3451",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyPressed_InputFlags",
+      "ret": "bool",
+      "signature": "(ImGuiKey,ImGuiInputFlags,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsKeyReleased": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsKeyReleased",
+      "defaults": {},
+      "funcname": "IsKeyReleased",
+      "location": "imgui:998",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyReleased_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKey key,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,ImGuiID owner_id)",
+      "call_args": "(key,owner_id)",
+      "cimguiname": "igIsKeyReleased",
+      "defaults": {},
+      "funcname": "IsKeyReleased",
+      "location": "imgui_internal:3452",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyReleased_ID",
+      "ret": "bool",
+      "signature": "(ImGuiKey,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsKeyboardKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsKeyboardKey",
+      "defaults": {},
+      "funcname": "IsKeyboardKey",
+      "location": "imgui_internal:3398",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsKeyboardKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsLRModKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsLRModKey",
+      "defaults": {},
+      "funcname": "IsLRModKey",
+      "location": "imgui_internal:3402",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsLRModKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsLegacyKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsLegacyKey",
+      "defaults": {},
+      "funcname": "IsLegacyKey",
+      "location": "imgui_internal:3397",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsLegacyKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseClicked": [
+    {
+      "args": "(ImGuiMouseButton button,bool repeat)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "repeat",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,bool repeat=false)",
+      "call_args": "(button,repeat)",
+      "cimguiname": "igIsMouseClicked",
+      "defaults": {
+        "repeat": "false"
+      },
+      "funcname": "IsMouseClicked",
+      "location": "imgui:1035",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseClicked_Bool",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiMouseButton button,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,ImGuiInputFlags flags,ImGuiID owner_id=0)",
+      "call_args": "(button,flags,owner_id)",
+      "cimguiname": "igIsMouseClicked",
+      "defaults": {
+        "owner_id": "0"
+      },
+      "funcname": "IsMouseClicked",
+      "location": "imgui_internal:3455",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseClicked_InputFlags",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,ImGuiInputFlags,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseDoubleClicked": [
+    {
+      "args": "(ImGuiMouseButton button)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button)",
+      "call_args": "(button)",
+      "cimguiname": "igIsMouseDoubleClicked",
+      "defaults": {},
+      "funcname": "IsMouseDoubleClicked",
+      "location": "imgui:1037",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseDoubleClicked_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiMouseButton button,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,ImGuiID owner_id)",
+      "call_args": "(button,owner_id)",
+      "cimguiname": "igIsMouseDoubleClicked",
+      "defaults": {},
+      "funcname": "IsMouseDoubleClicked",
+      "location": "imgui_internal:3457",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseDoubleClicked_ID",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseDown": [
+    {
+      "args": "(ImGuiMouseButton button)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button)",
+      "call_args": "(button)",
+      "cimguiname": "igIsMouseDown",
+      "defaults": {},
+      "funcname": "IsMouseDown",
+      "location": "imgui:1034",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseDown_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiMouseButton button,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,ImGuiID owner_id)",
+      "call_args": "(button,owner_id)",
+      "cimguiname": "igIsMouseDown",
+      "defaults": {},
+      "funcname": "IsMouseDown",
+      "location": "imgui_internal:3454",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseDown_ID",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseDragPastThreshold": [
+    {
+      "args": "(ImGuiMouseButton button,float lock_threshold)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "lock_threshold",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,float lock_threshold=-1.0f)",
+      "call_args": "(button,lock_threshold)",
+      "cimguiname": "igIsMouseDragPastThreshold",
+      "defaults": {
+        "lock_threshold": "-1.0f"
+      },
+      "funcname": "IsMouseDragPastThreshold",
+      "location": "imgui_internal:3417",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseDragPastThreshold",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,float)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseDragging": [
+    {
+      "args": "(ImGuiMouseButton button,float lock_threshold)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "lock_threshold",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,float lock_threshold=-1.0f)",
+      "call_args": "(button,lock_threshold)",
+      "cimguiname": "igIsMouseDragging",
+      "defaults": {
+        "lock_threshold": "-1.0f"
+      },
+      "funcname": "IsMouseDragging",
+      "location": "imgui:1044",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseDragging",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,float)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseHoveringRect": [
+    {
+      "args": "(const ImVec2 r_min,const ImVec2 r_max,bool clip)",
+      "argsT": [
+        {
+          "name": "r_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "r_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clip",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& r_min,const ImVec2& r_max,bool clip=true)",
+      "call_args": "(r_min,r_max,clip)",
+      "cimguiname": "igIsMouseHoveringRect",
+      "defaults": {
+        "clip": "true"
+      },
+      "funcname": "IsMouseHoveringRect",
+      "location": "imgui:1039",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseHoveringRect",
+      "ret": "bool",
+      "signature": "(const ImVec2,const ImVec2,bool)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsMouseKey",
+      "defaults": {},
+      "funcname": "IsMouseKey",
+      "location": "imgui_internal:3400",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsMousePosValid": [
+    {
+      "args": "(const ImVec2* mouse_pos)",
+      "argsT": [
+        {
+          "name": "mouse_pos",
+          "type": "const ImVec2*"
+        }
+      ],
+      "argsoriginal": "(const ImVec2* mouse_pos=((void*)0))",
+      "call_args": "(mouse_pos)",
+      "cimguiname": "igIsMousePosValid",
+      "defaults": {
+        "mouse_pos": "NULL"
+      },
+      "funcname": "IsMousePosValid",
+      "location": "imgui:1040",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMousePosValid",
+      "ret": "bool",
+      "signature": "(const ImVec2*)",
+      "stname": ""
+    }
+  ],
+  "igIsMouseReleased": [
+    {
+      "args": "(ImGuiMouseButton button)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button)",
+      "call_args": "(button)",
+      "cimguiname": "igIsMouseReleased",
+      "defaults": {},
+      "funcname": "IsMouseReleased",
+      "location": "imgui:1036",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseReleased_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiMouseButton button,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button,ImGuiID owner_id)",
+      "call_args": "(button,owner_id)",
+      "cimguiname": "igIsMouseReleased",
+      "defaults": {},
+      "funcname": "IsMouseReleased",
+      "location": "imgui_internal:3456",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsMouseReleased_ID",
+      "ret": "bool",
+      "signature": "(ImGuiMouseButton,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igIsNamedKey": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsNamedKey",
+      "defaults": {},
+      "funcname": "IsNamedKey",
+      "location": "imgui_internal:3395",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsNamedKey",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsNamedKeyOrMod": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igIsNamedKeyOrMod",
+      "defaults": {},
+      "funcname": "IsNamedKeyOrMod",
+      "location": "imgui_internal:3396",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsNamedKeyOrMod",
+      "ret": "bool",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    }
+  ],
+  "igIsPopupOpen": [
+    {
+      "args": "(const char* str_id,ImGuiPopupFlags flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiPopupFlags flags=0)",
+      "call_args": "(str_id,flags)",
+      "cimguiname": "igIsPopupOpen",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "IsPopupOpen",
+      "location": "imgui:797",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsPopupOpen_Str",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiPopupFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiID id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiPopupFlags popup_flags)",
+      "call_args": "(id,popup_flags)",
+      "cimguiname": "igIsPopupOpen",
+      "defaults": {},
+      "funcname": "IsPopupOpen",
+      "location": "imgui_internal:3346",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsPopupOpen_ID",
+      "ret": "bool",
+      "signature": "(ImGuiID,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igIsRectVisible": [
+    {
+      "args": "(const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size)",
+      "call_args": "(size)",
+      "cimguiname": "igIsRectVisible",
+      "defaults": {},
+      "funcname": "IsRectVisible",
+      "location": "imgui:974",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsRectVisible_Nil",
+      "ret": "bool",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImVec2 rect_min,const ImVec2 rect_max)",
+      "argsT": [
+        {
+          "name": "rect_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "rect_max",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& rect_min,const ImVec2& rect_max)",
+      "call_args": "(rect_min,rect_max)",
+      "cimguiname": "igIsRectVisible",
+      "defaults": {},
+      "funcname": "IsRectVisible",
+      "location": "imgui:975",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsRectVisible_Vec2",
+      "ret": "bool",
+      "signature": "(const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowAbove": [
+    {
+      "args": "(ImGuiWindow* potential_above,ImGuiWindow* potential_below)",
+      "argsT": [
+        {
+          "name": "potential_above",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "potential_below",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* potential_above,ImGuiWindow* potential_below)",
+      "call_args": "(potential_above,potential_below)",
+      "cimguiname": "igIsWindowAbove",
+      "defaults": {},
+      "funcname": "IsWindowAbove",
+      "location": "imgui_internal:3206",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowAbove",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowAppearing": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsWindowAppearing",
+      "defaults": {},
+      "funcname": "IsWindowAppearing",
+      "location": "imgui:401",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowAppearing",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsWindowChildOf": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "potential_parent",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "popup_hierarchy",
+          "type": "bool"
+        },
+        {
+          "name": "dock_hierarchy",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy)",
+      "call_args": "(window,potential_parent,popup_hierarchy,dock_hierarchy)",
+      "cimguiname": "igIsWindowChildOf",
+      "defaults": {},
+      "funcname": "IsWindowChildOf",
+      "location": "imgui_internal:3204",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowChildOf",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*,ImGuiWindow*,bool,bool)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowCollapsed": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsWindowCollapsed",
+      "defaults": {},
+      "funcname": "IsWindowCollapsed",
+      "location": "imgui:402",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowCollapsed",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsWindowContentHoverable": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiHoveredFlags flags)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiHoveredFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiHoveredFlags flags=0)",
+      "call_args": "(window,flags)",
+      "cimguiname": "igIsWindowContentHoverable",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "IsWindowContentHoverable",
+      "location": "imgui_internal:3318",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowContentHoverable",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*,ImGuiHoveredFlags)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowDocked": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igIsWindowDocked",
+      "defaults": {},
+      "funcname": "IsWindowDocked",
+      "location": "imgui:894",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowDocked",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igIsWindowFocused": [
+    {
+      "args": "(ImGuiFocusedFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiFocusedFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiFocusedFlags flags=0)",
+      "call_args": "(flags)",
+      "cimguiname": "igIsWindowFocused",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "IsWindowFocused",
+      "location": "imgui:403",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowFocused",
+      "ret": "bool",
+      "signature": "(ImGuiFocusedFlags)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowHovered": [
+    {
+      "args": "(ImGuiHoveredFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiHoveredFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiHoveredFlags flags=0)",
+      "call_args": "(flags)",
+      "cimguiname": "igIsWindowHovered",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "IsWindowHovered",
+      "location": "imgui:404",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowHovered",
+      "ret": "bool",
+      "signature": "(ImGuiHoveredFlags)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowNavFocusable": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igIsWindowNavFocusable",
+      "defaults": {},
+      "funcname": "IsWindowNavFocusable",
+      "location": "imgui_internal:3207",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowNavFocusable",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igIsWindowWithinBeginStackOf": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiWindow* potential_parent)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "potential_parent",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiWindow* potential_parent)",
+      "call_args": "(window,potential_parent)",
+      "cimguiname": "igIsWindowWithinBeginStackOf",
+      "defaults": {},
+      "funcname": "IsWindowWithinBeginStackOf",
+      "location": "imgui_internal:3205",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igIsWindowWithinBeginStackOf",
+      "ret": "bool",
+      "signature": "(ImGuiWindow*,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igItemAdd": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,const ImRect* nav_bb,ImGuiItemFlags extra_flags)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "nav_bb",
+          "type": "const ImRect*"
+        },
+        {
+          "name": "extra_flags",
+          "type": "ImGuiItemFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,const ImRect* nav_bb=((void*)0),ImGuiItemFlags extra_flags=0)",
+      "call_args": "(bb,id,nav_bb,extra_flags)",
+      "cimguiname": "igItemAdd",
+      "defaults": {
+        "extra_flags": "0",
+        "nav_bb": "NULL"
+      },
+      "funcname": "ItemAdd",
+      "location": "imgui_internal:3316",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igItemAdd",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,const ImRect*,ImGuiItemFlags)",
+      "stname": ""
+    }
+  ],
+  "igItemHoverable": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,ImGuiItemFlags item_flags)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "item_flags",
+          "type": "ImGuiItemFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,ImGuiItemFlags item_flags)",
+      "call_args": "(bb,id,item_flags)",
+      "cimguiname": "igItemHoverable",
+      "defaults": {},
+      "funcname": "ItemHoverable",
+      "location": "imgui_internal:3317",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igItemHoverable",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,ImGuiItemFlags)",
+      "stname": ""
+    }
+  ],
+  "igItemSize": [
+    {
+      "args": "(const ImVec2 size,float text_baseline_y)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "text_baseline_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size,float text_baseline_y=-1.0f)",
+      "call_args": "(size,text_baseline_y)",
+      "cimguiname": "igItemSize",
+      "defaults": {
+        "text_baseline_y": "-1.0f"
+      },
+      "funcname": "ItemSize",
+      "location": "imgui_internal:3314",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igItemSize_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2,float)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImRect bb,float text_baseline_y)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "text_baseline_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,float text_baseline_y=-1.0f)",
+      "call_args": "(bb,text_baseline_y)",
+      "cimguiname": "igItemSize",
+      "defaults": {
+        "text_baseline_y": "-1.0f"
+      },
+      "funcname": "ItemSize",
+      "location": "imgui_internal:3315",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igItemSize_Rect",
+      "ret": "void",
+      "signature": "(const ImRect,float)",
+      "stname": ""
+    }
+  ],
+  "igKeepAliveID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igKeepAliveID",
+      "defaults": {},
+      "funcname": "KeepAliveID",
+      "location": "imgui_internal:3307",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igKeepAliveID",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igLabelText": [
+    {
+      "args": "(const char* label,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* fmt,...)",
+      "call_args": "(label,fmt,...)",
+      "cimguiname": "igLabelText",
+      "defaults": {},
+      "funcname": "LabelText",
+      "isvararg": "...)",
+      "location": "imgui:548",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLabelText",
+      "ret": "void",
+      "signature": "(const char*,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igLabelTextV": [
+    {
+      "args": "(const char* label,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* fmt,va_list args)",
+      "call_args": "(label,fmt,args)",
+      "cimguiname": "igLabelTextV",
+      "defaults": {},
+      "funcname": "LabelTextV",
+      "location": "imgui:549",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLabelTextV",
+      "ret": "void",
+      "signature": "(const char*,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igListBox": [
+    {
+      "args": "(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "current_item",
+          "type": "int*"
+        },
+        {
+          "name": "items",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "height_in_items",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items=-1)",
+      "call_args": "(label,current_item,items,items_count,height_in_items)",
+      "cimguiname": "igListBox",
+      "defaults": {
+        "height_in_items": "-1"
+      },
+      "funcname": "ListBox",
+      "location": "imgui:709",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igListBox_Str_arr",
+      "ret": "bool",
+      "signature": "(const char*,int*,const char* const[],int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,int* current_item,const char*(*getter)(void* user_data,int idx),void* user_data,int items_count,int height_in_items)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "current_item",
+          "type": "int*"
+        },
+        {
+          "name": "getter",
+          "ret": "const char*",
+          "signature": "(void* user_data,int idx)",
+          "type": "const char*(*)(void* user_data,int idx)"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "height_in_items",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* current_item,const char*(*getter)(void* user_data,int idx),void* user_data,int items_count,int height_in_items=-1)",
+      "call_args": "(label,current_item,getter,user_data,items_count,height_in_items)",
+      "cimguiname": "igListBox",
+      "defaults": {
+        "height_in_items": "-1"
+      },
+      "funcname": "ListBox",
+      "location": "imgui:710",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igListBox_FnStrPtr",
+      "ret": "bool",
+      "signature": "(const char*,int*,const char*(*)(void*,int),void*,int,int)",
+      "stname": ""
+    }
+  ],
+  "igLoadIniSettingsFromDisk": [
+    {
+      "args": "(const char* ini_filename)",
+      "argsT": [
+        {
+          "name": "ini_filename",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* ini_filename)",
+      "call_args": "(ini_filename)",
+      "cimguiname": "igLoadIniSettingsFromDisk",
+      "defaults": {},
+      "funcname": "LoadIniSettingsFromDisk",
+      "location": "imgui:1060",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLoadIniSettingsFromDisk",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igLoadIniSettingsFromMemory": [
+    {
+      "args": "(const char* ini_data,size_t ini_size)",
+      "argsT": [
+        {
+          "name": "ini_data",
+          "type": "const char*"
+        },
+        {
+          "name": "ini_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* ini_data,size_t ini_size=0)",
+      "call_args": "(ini_data,ini_size)",
+      "cimguiname": "igLoadIniSettingsFromMemory",
+      "defaults": {
+        "ini_size": "0"
+      },
+      "funcname": "LoadIniSettingsFromMemory",
+      "location": "imgui:1061",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLoadIniSettingsFromMemory",
+      "ret": "void",
+      "signature": "(const char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "igLocalizeGetMsg": [
+    {
+      "args": "(ImGuiLocKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiLocKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiLocKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igLocalizeGetMsg",
+      "defaults": {},
+      "funcname": "LocalizeGetMsg",
+      "location": "imgui_internal:3281",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLocalizeGetMsg",
+      "ret": "const char*",
+      "signature": "(ImGuiLocKey)",
+      "stname": ""
+    }
+  ],
+  "igLocalizeRegisterEntries": [
+    {
+      "args": "(const ImGuiLocEntry* entries,int count)",
+      "argsT": [
+        {
+          "name": "entries",
+          "type": "const ImGuiLocEntry*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImGuiLocEntry* entries,int count)",
+      "call_args": "(entries,count)",
+      "cimguiname": "igLocalizeRegisterEntries",
+      "defaults": {},
+      "funcname": "LocalizeRegisterEntries",
+      "location": "imgui_internal:3280",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLocalizeRegisterEntries",
+      "ret": "void",
+      "signature": "(const ImGuiLocEntry*,int)",
+      "stname": ""
+    }
+  ],
+  "igLogBegin": [
+    {
+      "args": "(ImGuiLogFlags flags,int auto_open_depth)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiLogFlags"
+        },
+        {
+          "name": "auto_open_depth",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiLogFlags flags,int auto_open_depth)",
+      "call_args": "(flags,auto_open_depth)",
+      "cimguiname": "igLogBegin",
+      "defaults": {},
+      "funcname": "LogBegin",
+      "location": "imgui_internal:3332",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogBegin",
+      "ret": "void",
+      "signature": "(ImGuiLogFlags,int)",
+      "stname": ""
+    }
+  ],
+  "igLogButtons": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igLogButtons",
+      "defaults": {},
+      "funcname": "LogButtons",
+      "location": "imgui:902",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogButtons",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igLogFinish": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igLogFinish",
+      "defaults": {},
+      "funcname": "LogFinish",
+      "location": "imgui:901",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogFinish",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igLogRenderedText": [
+    {
+      "args": "(const ImVec2* ref_pos,const char* text,const char* text_end)",
+      "argsT": [
+        {
+          "name": "ref_pos",
+          "type": "const ImVec2*"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const ImVec2* ref_pos,const char* text,const char* text_end=((void*)0))",
+      "call_args": "(ref_pos,text,text_end)",
+      "cimguiname": "igLogRenderedText",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "LogRenderedText",
+      "location": "imgui_internal:3334",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogRenderedText",
+      "ret": "void",
+      "signature": "(const ImVec2*,const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igLogSetNextTextDecoration": [
+    {
+      "args": "(const char* prefix,const char* suffix)",
+      "argsT": [
+        {
+          "name": "prefix",
+          "type": "const char*"
+        },
+        {
+          "name": "suffix",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* prefix,const char* suffix)",
+      "call_args": "(prefix,suffix)",
+      "cimguiname": "igLogSetNextTextDecoration",
+      "defaults": {},
+      "funcname": "LogSetNextTextDecoration",
+      "location": "imgui_internal:3335",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogSetNextTextDecoration",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igLogText": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt, ...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igLogText",
+      "defaults": {},
+      "funcname": "LogText",
+      "isvararg": "...)",
+      "location": "imgui:903",
+      "manual": true,
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogText",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igLogTextV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igLogTextV",
+      "defaults": {},
+      "funcname": "LogTextV",
+      "location": "imgui:904",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogTextV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igLogToBuffer": [
+    {
+      "args": "(int auto_open_depth)",
+      "argsT": [
+        {
+          "name": "auto_open_depth",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int auto_open_depth=-1)",
+      "call_args": "(auto_open_depth)",
+      "cimguiname": "igLogToBuffer",
+      "defaults": {
+        "auto_open_depth": "-1"
+      },
+      "funcname": "LogToBuffer",
+      "location": "imgui_internal:3333",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogToBuffer",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igLogToClipboard": [
+    {
+      "args": "(int auto_open_depth)",
+      "argsT": [
+        {
+          "name": "auto_open_depth",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int auto_open_depth=-1)",
+      "call_args": "(auto_open_depth)",
+      "cimguiname": "igLogToClipboard",
+      "defaults": {
+        "auto_open_depth": "-1"
+      },
+      "funcname": "LogToClipboard",
+      "location": "imgui:900",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogToClipboard",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igLogToFile": [
+    {
+      "args": "(int auto_open_depth,const char* filename)",
+      "argsT": [
+        {
+          "name": "auto_open_depth",
+          "type": "int"
+        },
+        {
+          "name": "filename",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(int auto_open_depth=-1,const char* filename=((void*)0))",
+      "call_args": "(auto_open_depth,filename)",
+      "cimguiname": "igLogToFile",
+      "defaults": {
+        "auto_open_depth": "-1",
+        "filename": "NULL"
+      },
+      "funcname": "LogToFile",
+      "location": "imgui:899",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogToFile",
+      "ret": "void",
+      "signature": "(int,const char*)",
+      "stname": ""
+    }
+  ],
+  "igLogToTTY": [
+    {
+      "args": "(int auto_open_depth)",
+      "argsT": [
+        {
+          "name": "auto_open_depth",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int auto_open_depth=-1)",
+      "call_args": "(auto_open_depth)",
+      "cimguiname": "igLogToTTY",
+      "defaults": {
+        "auto_open_depth": "-1"
+      },
+      "funcname": "LogToTTY",
+      "location": "imgui:898",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igLogToTTY",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igMarkIniSettingsDirty": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igMarkIniSettingsDirty",
+      "defaults": {},
+      "funcname": "MarkIniSettingsDirty",
+      "location": "imgui_internal:3266",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMarkIniSettingsDirty_Nil",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igMarkIniSettingsDirty",
+      "defaults": {},
+      "funcname": "MarkIniSettingsDirty",
+      "location": "imgui_internal:3267",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMarkIniSettingsDirty_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igMarkItemEdited": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igMarkItemEdited",
+      "defaults": {},
+      "funcname": "MarkItemEdited",
+      "location": "imgui_internal:3308",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMarkItemEdited",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igMemAlloc": [
+    {
+      "args": "(size_t size)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(size_t size)",
+      "call_args": "(size)",
+      "cimguiname": "igMemAlloc",
+      "defaults": {},
+      "funcname": "MemAlloc",
+      "location": "imgui:1082",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMemAlloc",
+      "ret": "void*",
+      "signature": "(size_t)",
+      "stname": ""
+    }
+  ],
+  "igMemFree": [
+    {
+      "args": "(void* ptr)",
+      "argsT": [
+        {
+          "name": "ptr",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void* ptr)",
+      "call_args": "(ptr)",
+      "cimguiname": "igMemFree",
+      "defaults": {},
+      "funcname": "MemFree",
+      "location": "imgui:1083",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMemFree",
+      "ret": "void",
+      "signature": "(void*)",
+      "stname": ""
+    }
+  ],
+  "igMenuItem": [
+    {
+      "args": "(const char* label,const char* shortcut,bool selected,bool enabled)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "shortcut",
+          "type": "const char*"
+        },
+        {
+          "name": "selected",
+          "type": "bool"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* shortcut=((void*)0),bool selected=false,bool enabled=true)",
+      "call_args": "(label,shortcut,selected,enabled)",
+      "cimguiname": "igMenuItem",
+      "defaults": {
+        "enabled": "true",
+        "selected": "false",
+        "shortcut": "NULL"
+      },
+      "funcname": "MenuItem",
+      "location": "imgui:737",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMenuItem_Bool",
+      "ret": "bool",
+      "signature": "(const char*,const char*,bool,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,const char* shortcut,bool* p_selected,bool enabled)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "shortcut",
+          "type": "const char*"
+        },
+        {
+          "name": "p_selected",
+          "type": "bool*"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* shortcut,bool* p_selected,bool enabled=true)",
+      "call_args": "(label,shortcut,p_selected,enabled)",
+      "cimguiname": "igMenuItem",
+      "defaults": {
+        "enabled": "true"
+      },
+      "funcname": "MenuItem",
+      "location": "imgui:738",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMenuItem_BoolPtr",
+      "ret": "bool",
+      "signature": "(const char*,const char*,bool*,bool)",
+      "stname": ""
+    }
+  ],
+  "igMenuItemEx": [
+    {
+      "args": "(const char* label,const char* icon,const char* shortcut,bool selected,bool enabled)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "icon",
+          "type": "const char*"
+        },
+        {
+          "name": "shortcut",
+          "type": "const char*"
+        },
+        {
+          "name": "selected",
+          "type": "bool"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* icon,const char* shortcut=((void*)0),bool selected=false,bool enabled=true)",
+      "call_args": "(label,icon,shortcut,selected,enabled)",
+      "cimguiname": "igMenuItemEx",
+      "defaults": {
+        "enabled": "true",
+        "selected": "false",
+        "shortcut": "NULL"
+      },
+      "funcname": "MenuItemEx",
+      "location": "imgui_internal:3361",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMenuItemEx",
+      "ret": "bool",
+      "signature": "(const char*,const char*,const char*,bool,bool)",
+      "stname": ""
+    }
+  ],
+  "igMouseButtonToKey": [
+    {
+      "args": "(ImGuiMouseButton button)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button)",
+      "call_args": "(button)",
+      "cimguiname": "igMouseButtonToKey",
+      "defaults": {},
+      "funcname": "MouseButtonToKey",
+      "location": "imgui_internal:3416",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMouseButtonToKey",
+      "ret": "ImGuiKey",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    }
+  ],
+  "igMultiSelectAddSetAll": [
+    {
+      "args": "(ImGuiMultiSelectTempData* ms,bool selected)",
+      "argsT": [
+        {
+          "name": "ms",
+          "type": "ImGuiMultiSelectTempData*"
+        },
+        {
+          "name": "selected",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiMultiSelectTempData* ms,bool selected)",
+      "call_args": "(ms,selected)",
+      "cimguiname": "igMultiSelectAddSetAll",
+      "defaults": {},
+      "funcname": "MultiSelectAddSetAll",
+      "location": "imgui_internal:3567",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMultiSelectAddSetAll",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectTempData*,bool)",
+      "stname": ""
+    }
+  ],
+  "igMultiSelectAddSetRange": [
+    {
+      "args": "(ImGuiMultiSelectTempData* ms,bool selected,int range_dir,ImGuiSelectionUserData first_item,ImGuiSelectionUserData last_item)",
+      "argsT": [
+        {
+          "name": "ms",
+          "type": "ImGuiMultiSelectTempData*"
+        },
+        {
+          "name": "selected",
+          "type": "bool"
+        },
+        {
+          "name": "range_dir",
+          "type": "int"
+        },
+        {
+          "name": "first_item",
+          "type": "ImGuiSelectionUserData"
+        },
+        {
+          "name": "last_item",
+          "type": "ImGuiSelectionUserData"
+        }
+      ],
+      "argsoriginal": "(ImGuiMultiSelectTempData* ms,bool selected,int range_dir,ImGuiSelectionUserData first_item,ImGuiSelectionUserData last_item)",
+      "call_args": "(ms,selected,range_dir,first_item,last_item)",
+      "cimguiname": "igMultiSelectAddSetRange",
+      "defaults": {},
+      "funcname": "MultiSelectAddSetRange",
+      "location": "imgui_internal:3568",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMultiSelectAddSetRange",
+      "ret": "void",
+      "signature": "(ImGuiMultiSelectTempData*,bool,int,ImGuiSelectionUserData,ImGuiSelectionUserData)",
+      "stname": ""
+    }
+  ],
+  "igMultiSelectItemFooter": [
+    {
+      "args": "(ImGuiID id,bool* p_selected,bool* p_pressed)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "p_selected",
+          "type": "bool*"
+        },
+        {
+          "name": "p_pressed",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,bool* p_selected,bool* p_pressed)",
+      "call_args": "(id,p_selected,p_pressed)",
+      "cimguiname": "igMultiSelectItemFooter",
+      "defaults": {},
+      "funcname": "MultiSelectItemFooter",
+      "location": "imgui_internal:3566",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMultiSelectItemFooter",
+      "ret": "void",
+      "signature": "(ImGuiID,bool*,bool*)",
+      "stname": ""
+    }
+  ],
+  "igMultiSelectItemHeader": [
+    {
+      "args": "(ImGuiID id,bool* p_selected,ImGuiButtonFlags* p_button_flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "p_selected",
+          "type": "bool*"
+        },
+        {
+          "name": "p_button_flags",
+          "type": "ImGuiButtonFlags*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,bool* p_selected,ImGuiButtonFlags* p_button_flags)",
+      "call_args": "(id,p_selected,p_button_flags)",
+      "cimguiname": "igMultiSelectItemHeader",
+      "defaults": {},
+      "funcname": "MultiSelectItemHeader",
+      "location": "imgui_internal:3565",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igMultiSelectItemHeader",
+      "ret": "void",
+      "signature": "(ImGuiID,bool*,ImGuiButtonFlags*)",
+      "stname": ""
+    }
+  ],
+  "igNavClearPreferredPosForAxis": [
+    {
+      "args": "(ImGuiAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        }
+      ],
+      "argsoriginal": "(ImGuiAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "igNavClearPreferredPosForAxis",
+      "defaults": {},
+      "funcname": "NavClearPreferredPosForAxis",
+      "location": "imgui_internal:3380",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavClearPreferredPosForAxis",
+      "ret": "void",
+      "signature": "(ImGuiAxis)",
+      "stname": ""
+    }
+  ],
+  "igNavHighlightActivated": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igNavHighlightActivated",
+      "defaults": {},
+      "funcname": "NavHighlightActivated",
+      "location": "imgui_internal:3379",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavHighlightActivated",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igNavInitRequestApplyResult": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNavInitRequestApplyResult",
+      "defaults": {},
+      "funcname": "NavInitRequestApplyResult",
+      "location": "imgui_internal:3370",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavInitRequestApplyResult",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNavInitWindow": [
+    {
+      "args": "(ImGuiWindow* window,bool force_reinit)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "force_reinit",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,bool force_reinit)",
+      "call_args": "(window,force_reinit)",
+      "cimguiname": "igNavInitWindow",
+      "defaults": {},
+      "funcname": "NavInitWindow",
+      "location": "imgui_internal:3369",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavInitWindow",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,bool)",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestApplyResult": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNavMoveRequestApplyResult",
+      "defaults": {},
+      "funcname": "NavMoveRequestApplyResult",
+      "location": "imgui_internal:3377",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestApplyResult",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestButNoResultYet": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNavMoveRequestButNoResultYet",
+      "defaults": {},
+      "funcname": "NavMoveRequestButNoResultYet",
+      "location": "imgui_internal:3371",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestButNoResultYet",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestCancel": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNavMoveRequestCancel",
+      "defaults": {},
+      "funcname": "NavMoveRequestCancel",
+      "location": "imgui_internal:3376",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestCancel",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestForward": [
+    {
+      "args": "(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags)",
+      "argsT": [
+        {
+          "name": "move_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "clip_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "move_flags",
+          "type": "ImGuiNavMoveFlags"
+        },
+        {
+          "name": "scroll_flags",
+          "type": "ImGuiScrollFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags)",
+      "call_args": "(move_dir,clip_dir,move_flags,scroll_flags)",
+      "cimguiname": "igNavMoveRequestForward",
+      "defaults": {},
+      "funcname": "NavMoveRequestForward",
+      "location": "imgui_internal:3373",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestForward",
+      "ret": "void",
+      "signature": "(ImGuiDir,ImGuiDir,ImGuiNavMoveFlags,ImGuiScrollFlags)",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestResolveWithLastItem": [
+    {
+      "args": "(ImGuiNavItemData* result)",
+      "argsT": [
+        {
+          "name": "result",
+          "type": "ImGuiNavItemData*"
+        }
+      ],
+      "argsoriginal": "(ImGuiNavItemData* result)",
+      "call_args": "(result)",
+      "cimguiname": "igNavMoveRequestResolveWithLastItem",
+      "defaults": {},
+      "funcname": "NavMoveRequestResolveWithLastItem",
+      "location": "imgui_internal:3374",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestResolveWithLastItem",
+      "ret": "void",
+      "signature": "(ImGuiNavItemData*)",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestResolveWithPastTreeNode": [
+    {
+      "args": "(ImGuiNavItemData* result,ImGuiTreeNodeStackData* tree_node_data)",
+      "argsT": [
+        {
+          "name": "result",
+          "type": "ImGuiNavItemData*"
+        },
+        {
+          "name": "tree_node_data",
+          "type": "ImGuiTreeNodeStackData*"
+        }
+      ],
+      "argsoriginal": "(ImGuiNavItemData* result,ImGuiTreeNodeStackData* tree_node_data)",
+      "call_args": "(result,tree_node_data)",
+      "cimguiname": "igNavMoveRequestResolveWithPastTreeNode",
+      "defaults": {},
+      "funcname": "NavMoveRequestResolveWithPastTreeNode",
+      "location": "imgui_internal:3375",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestResolveWithPastTreeNode",
+      "ret": "void",
+      "signature": "(ImGuiNavItemData*,ImGuiTreeNodeStackData*)",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestSubmit": [
+    {
+      "args": "(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags)",
+      "argsT": [
+        {
+          "name": "move_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "clip_dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "move_flags",
+          "type": "ImGuiNavMoveFlags"
+        },
+        {
+          "name": "scroll_flags",
+          "type": "ImGuiScrollFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiDir move_dir,ImGuiDir clip_dir,ImGuiNavMoveFlags move_flags,ImGuiScrollFlags scroll_flags)",
+      "call_args": "(move_dir,clip_dir,move_flags,scroll_flags)",
+      "cimguiname": "igNavMoveRequestSubmit",
+      "defaults": {},
+      "funcname": "NavMoveRequestSubmit",
+      "location": "imgui_internal:3372",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestSubmit",
+      "ret": "void",
+      "signature": "(ImGuiDir,ImGuiDir,ImGuiNavMoveFlags,ImGuiScrollFlags)",
+      "stname": ""
+    }
+  ],
+  "igNavMoveRequestTryWrapping": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiNavMoveFlags move_flags)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "move_flags",
+          "type": "ImGuiNavMoveFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiNavMoveFlags move_flags)",
+      "call_args": "(window,move_flags)",
+      "cimguiname": "igNavMoveRequestTryWrapping",
+      "defaults": {},
+      "funcname": "NavMoveRequestTryWrapping",
+      "location": "imgui_internal:3378",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavMoveRequestTryWrapping",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiNavMoveFlags)",
+      "stname": ""
+    }
+  ],
+  "igNavUpdateCurrentWindowIsScrollPushableX": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNavUpdateCurrentWindowIsScrollPushableX",
+      "defaults": {},
+      "funcname": "NavUpdateCurrentWindowIsScrollPushableX",
+      "location": "imgui_internal:3382",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNavUpdateCurrentWindowIsScrollPushableX",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNewFrame",
+      "defaults": {},
+      "funcname": "NewFrame",
+      "location": "imgui:340",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNewLine": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNewLine",
+      "defaults": {},
+      "funcname": "NewLine",
+      "location": "imgui:504",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNewLine",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igNextColumn": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igNextColumn",
+      "defaults": {},
+      "funcname": "NextColumn",
+      "location": "imgui:859",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igNextColumn",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igOpenPopup": [
+    {
+      "args": "(const char* str_id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiPopupFlags popup_flags=0)",
+      "call_args": "(str_id,popup_flags)",
+      "cimguiname": "igOpenPopup",
+      "defaults": {
+        "popup_flags": "0"
+      },
+      "funcname": "OpenPopup",
+      "location": "imgui:779",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igOpenPopup_Str",
+      "ret": "void",
+      "signature": "(const char*,ImGuiPopupFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiID id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiPopupFlags popup_flags=0)",
+      "call_args": "(id,popup_flags)",
+      "cimguiname": "igOpenPopup",
+      "defaults": {
+        "popup_flags": "0"
+      },
+      "funcname": "OpenPopup",
+      "location": "imgui:780",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igOpenPopup_ID",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igOpenPopupEx": [
+    {
+      "args": "(ImGuiID id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiPopupFlags popup_flags=ImGuiPopupFlags_None)",
+      "call_args": "(id,popup_flags)",
+      "cimguiname": "igOpenPopupEx",
+      "defaults": {
+        "popup_flags": "ImGuiPopupFlags_None"
+      },
+      "funcname": "OpenPopupEx",
+      "location": "imgui_internal:3342",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igOpenPopupEx",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igOpenPopupOnItemClick": [
+    {
+      "args": "(const char* str_id,ImGuiPopupFlags popup_flags)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "popup_flags",
+          "type": "ImGuiPopupFlags"
+        }
+      ],
+      "argsoriginal": "(const char* str_id=((void*)0),ImGuiPopupFlags popup_flags=1)",
+      "call_args": "(str_id,popup_flags)",
+      "cimguiname": "igOpenPopupOnItemClick",
+      "defaults": {
+        "popup_flags": "1",
+        "str_id": "NULL"
+      },
+      "funcname": "OpenPopupOnItemClick",
+      "location": "imgui:781",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igOpenPopupOnItemClick",
+      "ret": "void",
+      "signature": "(const char*,ImGuiPopupFlags)",
+      "stname": ""
+    }
+  ],
+  "igPlotEx": [
+    {
+      "args": "(ImGuiPlotType plot_type,const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,const ImVec2 size_arg)",
+      "argsT": [
+        {
+          "name": "plot_type",
+          "type": "ImGuiPlotType"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "values_getter",
+          "ret": "float",
+          "signature": "(void* data,int idx)",
+          "type": "float(*)(void* data,int idx)"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "values_count",
+          "type": "int"
+        },
+        {
+          "name": "values_offset",
+          "type": "int"
+        },
+        {
+          "name": "overlay_text",
+          "type": "const char*"
+        },
+        {
+          "name": "scale_min",
+          "type": "float"
+        },
+        {
+          "name": "scale_max",
+          "type": "float"
+        },
+        {
+          "name": "size_arg",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiPlotType plot_type,const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,const ImVec2& size_arg)",
+      "call_args": "(plot_type,label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,size_arg)",
+      "cimguiname": "igPlotEx",
+      "defaults": {},
+      "funcname": "PlotEx",
+      "location": "imgui_internal:3758",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPlotEx",
+      "ret": "int",
+      "signature": "(ImGuiPlotType,const char*,float(*)(void*,int),void*,int,int,const char*,float,float,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igPlotHistogram": [
+    {
+      "args": "(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "values_count",
+          "type": "int"
+        },
+        {
+          "name": "values_offset",
+          "type": "int"
+        },
+        {
+          "name": "overlay_text",
+          "type": "const char*"
+        },
+        {
+          "name": "scale_min",
+          "type": "float"
+        },
+        {
+          "name": "scale_max",
+          "type": "float"
+        },
+        {
+          "name": "graph_size",
+          "type": "ImVec2"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,const float* values,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282346638528859811704183484516925e+38F,float scale_max=3.40282346638528859811704183484516925e+38F,ImVec2 graph_size=ImVec2(0,0),int stride=sizeof(float))",
+      "call_args": "(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride)",
+      "cimguiname": "igPlotHistogram",
+      "defaults": {
+        "graph_size": "ImVec2(0,0)",
+        "overlay_text": "NULL",
+        "scale_max": "FLT_MAX",
+        "scale_min": "FLT_MAX",
+        "stride": "sizeof(float)",
+        "values_offset": "0"
+      },
+      "funcname": "PlotHistogram",
+      "location": "imgui:716",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPlotHistogram_FloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,int,const char*,float,float,ImVec2,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "values_getter",
+          "ret": "float",
+          "signature": "(void* data,int idx)",
+          "type": "float(*)(void* data,int idx)"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "values_count",
+          "type": "int"
+        },
+        {
+          "name": "values_offset",
+          "type": "int"
+        },
+        {
+          "name": "overlay_text",
+          "type": "const char*"
+        },
+        {
+          "name": "scale_min",
+          "type": "float"
+        },
+        {
+          "name": "scale_max",
+          "type": "float"
+        },
+        {
+          "name": "graph_size",
+          "type": "ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282346638528859811704183484516925e+38F,float scale_max=3.40282346638528859811704183484516925e+38F,ImVec2 graph_size=ImVec2(0,0))",
+      "call_args": "(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size)",
+      "cimguiname": "igPlotHistogram",
+      "defaults": {
+        "graph_size": "ImVec2(0,0)",
+        "overlay_text": "NULL",
+        "scale_max": "FLT_MAX",
+        "scale_min": "FLT_MAX",
+        "values_offset": "0"
+      },
+      "funcname": "PlotHistogram",
+      "location": "imgui:717",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPlotHistogram_FnFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igPlotLines": [
+    {
+      "args": "(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "values_count",
+          "type": "int"
+        },
+        {
+          "name": "values_offset",
+          "type": "int"
+        },
+        {
+          "name": "overlay_text",
+          "type": "const char*"
+        },
+        {
+          "name": "scale_min",
+          "type": "float"
+        },
+        {
+          "name": "scale_max",
+          "type": "float"
+        },
+        {
+          "name": "graph_size",
+          "type": "ImVec2"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,const float* values,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282346638528859811704183484516925e+38F,float scale_max=3.40282346638528859811704183484516925e+38F,ImVec2 graph_size=ImVec2(0,0),int stride=sizeof(float))",
+      "call_args": "(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride)",
+      "cimguiname": "igPlotLines",
+      "defaults": {
+        "graph_size": "ImVec2(0,0)",
+        "overlay_text": "NULL",
+        "scale_max": "FLT_MAX",
+        "scale_min": "FLT_MAX",
+        "stride": "sizeof(float)",
+        "values_offset": "0"
+      },
+      "funcname": "PlotLines",
+      "location": "imgui:714",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPlotLines_FloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,int,const char*,float,float,ImVec2,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "values_getter",
+          "ret": "float",
+          "signature": "(void* data,int idx)",
+          "type": "float(*)(void* data,int idx)"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "values_count",
+          "type": "int"
+        },
+        {
+          "name": "values_offset",
+          "type": "int"
+        },
+        {
+          "name": "overlay_text",
+          "type": "const char*"
+        },
+        {
+          "name": "scale_min",
+          "type": "float"
+        },
+        {
+          "name": "scale_max",
+          "type": "float"
+        },
+        {
+          "name": "graph_size",
+          "type": "ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset=0,const char* overlay_text=((void*)0),float scale_min=3.40282346638528859811704183484516925e+38F,float scale_max=3.40282346638528859811704183484516925e+38F,ImVec2 graph_size=ImVec2(0,0))",
+      "call_args": "(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size)",
+      "cimguiname": "igPlotLines",
+      "defaults": {
+        "graph_size": "ImVec2(0,0)",
+        "overlay_text": "NULL",
+        "scale_max": "FLT_MAX",
+        "scale_min": "FLT_MAX",
+        "values_offset": "0"
+      },
+      "funcname": "PlotLines",
+      "location": "imgui:715",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPlotLines_FnFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igPopClipRect": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopClipRect",
+      "defaults": {},
+      "funcname": "PopClipRect",
+      "location": "imgui:930",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopClipRect",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopColumnsBackground": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopColumnsBackground",
+      "defaults": {},
+      "funcname": "PopColumnsBackground",
+      "location": "imgui_internal:3578",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopColumnsBackground",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopFocusScope": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopFocusScope",
+      "defaults": {},
+      "funcname": "PopFocusScope",
+      "location": "imgui_internal:3542",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopFocusScope",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopFont": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopFont",
+      "defaults": {},
+      "funcname": "PopFont",
+      "location": "imgui:450",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopFont",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopID": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopID",
+      "defaults": {},
+      "funcname": "PopID",
+      "location": "imgui:532",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopID",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopItemFlag": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopItemFlag",
+      "defaults": {},
+      "funcname": "PopItemFlag",
+      "location": "imgui:460",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopItemFlag",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopItemWidth": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopItemWidth",
+      "defaults": {},
+      "funcname": "PopItemWidth",
+      "location": "imgui:464",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopItemWidth",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPopStyleColor": [
+    {
+      "args": "(int count)",
+      "argsT": [
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int count=1)",
+      "call_args": "(count)",
+      "cimguiname": "igPopStyleColor",
+      "defaults": {
+        "count": "1"
+      },
+      "funcname": "PopStyleColor",
+      "location": "imgui:453",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopStyleColor",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igPopStyleVar": [
+    {
+      "args": "(int count)",
+      "argsT": [
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int count=1)",
+      "call_args": "(count)",
+      "cimguiname": "igPopStyleVar",
+      "defaults": {
+        "count": "1"
+      },
+      "funcname": "PopStyleVar",
+      "location": "imgui:458",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopStyleVar",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igPopTextWrapPos": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPopTextWrapPos",
+      "defaults": {},
+      "funcname": "PopTextWrapPos",
+      "location": "imgui:468",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPopTextWrapPos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igProgressBar": [
+    {
+      "args": "(float fraction,const ImVec2 size_arg,const char* overlay)",
+      "argsT": [
+        {
+          "name": "fraction",
+          "type": "float"
+        },
+        {
+          "name": "size_arg",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "overlay",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(float fraction,const ImVec2& size_arg=ImVec2(-1.17549435082228750796873653722224568e-38F,0),const char* overlay=((void*)0))",
+      "call_args": "(fraction,size_arg,overlay)",
+      "cimguiname": "igProgressBar",
+      "defaults": {
+        "overlay": "NULL",
+        "size_arg": "ImVec2(-FLT_MIN,0)"
+      },
+      "funcname": "ProgressBar",
+      "location": "imgui:566",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igProgressBar",
+      "ret": "void",
+      "signature": "(float,const ImVec2,const char*)",
+      "stname": ""
+    }
+  ],
+  "igPushClipRect": [
+    {
+      "args": "(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max,bool intersect_with_current_clip_rect)",
+      "argsT": [
+        {
+          "name": "clip_rect_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clip_rect_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "intersect_with_current_clip_rect",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& clip_rect_min,const ImVec2& clip_rect_max,bool intersect_with_current_clip_rect)",
+      "call_args": "(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect)",
+      "cimguiname": "igPushClipRect",
+      "defaults": {},
+      "funcname": "PushClipRect",
+      "location": "imgui:929",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushClipRect",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,bool)",
+      "stname": ""
+    }
+  ],
+  "igPushColumnClipRect": [
+    {
+      "args": "(int column_index)",
+      "argsT": [
+        {
+          "name": "column_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_index)",
+      "call_args": "(column_index)",
+      "cimguiname": "igPushColumnClipRect",
+      "defaults": {},
+      "funcname": "PushColumnClipRect",
+      "location": "imgui_internal:3576",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushColumnClipRect",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igPushColumnsBackground": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igPushColumnsBackground",
+      "defaults": {},
+      "funcname": "PushColumnsBackground",
+      "location": "imgui_internal:3577",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushColumnsBackground",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igPushFocusScope": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igPushFocusScope",
+      "defaults": {},
+      "funcname": "PushFocusScope",
+      "location": "imgui_internal:3541",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushFocusScope",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igPushFont": [
+    {
+      "args": "(ImFont* font)",
+      "argsT": [
+        {
+          "name": "font",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "(ImFont* font)",
+      "call_args": "(font)",
+      "cimguiname": "igPushFont",
+      "defaults": {},
+      "funcname": "PushFont",
+      "location": "imgui:449",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushFont",
+      "ret": "void",
+      "signature": "(ImFont*)",
+      "stname": ""
+    }
+  ],
+  "igPushID": [
+    {
+      "args": "(const char* str_id)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str_id)",
+      "call_args": "(str_id)",
+      "cimguiname": "igPushID",
+      "defaults": {},
+      "funcname": "PushID",
+      "location": "imgui:528",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushID_Str",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* str_id_begin,const char* str_id_end)",
+      "argsT": [
+        {
+          "name": "str_id_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "str_id_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str_id_begin,const char* str_id_end)",
+      "call_args": "(str_id_begin,str_id_end)",
+      "cimguiname": "igPushID",
+      "defaults": {},
+      "funcname": "PushID",
+      "location": "imgui:529",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushID_StrStr",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id)",
+      "call_args": "(ptr_id)",
+      "cimguiname": "igPushID",
+      "defaults": {},
+      "funcname": "PushID",
+      "location": "imgui:530",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushID_Ptr",
+      "ret": "void",
+      "signature": "(const void*)",
+      "stname": ""
+    },
+    {
+      "args": "(int int_id)",
+      "argsT": [
+        {
+          "name": "int_id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int int_id)",
+      "call_args": "(int_id)",
+      "cimguiname": "igPushID",
+      "defaults": {},
+      "funcname": "PushID",
+      "location": "imgui:531",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushID_Int",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igPushItemFlag": [
+    {
+      "args": "(ImGuiItemFlags option,bool enabled)",
+      "argsT": [
+        {
+          "name": "option",
+          "type": "ImGuiItemFlags"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiItemFlags option,bool enabled)",
+      "call_args": "(option,enabled)",
+      "cimguiname": "igPushItemFlag",
+      "defaults": {},
+      "funcname": "PushItemFlag",
+      "location": "imgui:459",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushItemFlag",
+      "ret": "void",
+      "signature": "(ImGuiItemFlags,bool)",
+      "stname": ""
+    }
+  ],
+  "igPushItemWidth": [
+    {
+      "args": "(float item_width)",
+      "argsT": [
+        {
+          "name": "item_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float item_width)",
+      "call_args": "(item_width)",
+      "cimguiname": "igPushItemWidth",
+      "defaults": {},
+      "funcname": "PushItemWidth",
+      "location": "imgui:463",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushItemWidth",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igPushMultiItemsWidths": [
+    {
+      "args": "(int components,float width_full)",
+      "argsT": [
+        {
+          "name": "components",
+          "type": "int"
+        },
+        {
+          "name": "width_full",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(int components,float width_full)",
+      "call_args": "(components,width_full)",
+      "cimguiname": "igPushMultiItemsWidths",
+      "defaults": {},
+      "funcname": "PushMultiItemsWidths",
+      "location": "imgui_internal:3323",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushMultiItemsWidths",
+      "ret": "void",
+      "signature": "(int,float)",
+      "stname": ""
+    }
+  ],
+  "igPushOverrideID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igPushOverrideID",
+      "defaults": {},
+      "funcname": "PushOverrideID",
+      "location": "imgui_internal:3309",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushOverrideID",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igPushStyleColor": [
+    {
+      "args": "(ImGuiCol idx,ImU32 col)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiCol"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImGuiCol idx,ImU32 col)",
+      "call_args": "(idx,col)",
+      "cimguiname": "igPushStyleColor",
+      "defaults": {},
+      "funcname": "PushStyleColor",
+      "location": "imgui:451",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushStyleColor_U32",
+      "ret": "void",
+      "signature": "(ImGuiCol,ImU32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiCol idx,const ImVec4 col)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiCol"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(ImGuiCol idx,const ImVec4& col)",
+      "call_args": "(idx,col)",
+      "cimguiname": "igPushStyleColor",
+      "defaults": {},
+      "funcname": "PushStyleColor",
+      "location": "imgui:452",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushStyleColor_Vec4",
+      "ret": "void",
+      "signature": "(ImGuiCol,const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "igPushStyleVar": [
+    {
+      "args": "(ImGuiStyleVar idx,float val)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "val",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,float val)",
+      "call_args": "(idx,val)",
+      "cimguiname": "igPushStyleVar",
+      "defaults": {},
+      "funcname": "PushStyleVar",
+      "location": "imgui:454",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushStyleVar_Float",
+      "ret": "void",
+      "signature": "(ImGuiStyleVar,float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiStyleVar idx,const ImVec2 val)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "val",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,const ImVec2& val)",
+      "call_args": "(idx,val)",
+      "cimguiname": "igPushStyleVar",
+      "defaults": {},
+      "funcname": "PushStyleVar",
+      "location": "imgui:455",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushStyleVar_Vec2",
+      "ret": "void",
+      "signature": "(ImGuiStyleVar,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igPushStyleVarX": [
+    {
+      "args": "(ImGuiStyleVar idx,float val_x)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "val_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,float val_x)",
+      "call_args": "(idx,val_x)",
+      "cimguiname": "igPushStyleVarX",
+      "defaults": {},
+      "funcname": "PushStyleVarX",
+      "location": "imgui:456",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushStyleVarX",
+      "ret": "void",
+      "signature": "(ImGuiStyleVar,float)",
+      "stname": ""
+    }
+  ],
+  "igPushStyleVarY": [
+    {
+      "args": "(ImGuiStyleVar idx,float val_y)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImGuiStyleVar"
+        },
+        {
+          "name": "val_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyleVar idx,float val_y)",
+      "call_args": "(idx,val_y)",
+      "cimguiname": "igPushStyleVarY",
+      "defaults": {},
+      "funcname": "PushStyleVarY",
+      "location": "imgui:457",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushStyleVarY",
+      "ret": "void",
+      "signature": "(ImGuiStyleVar,float)",
+      "stname": ""
+    }
+  ],
+  "igPushTextWrapPos": [
+    {
+      "args": "(float wrap_local_pos_x)",
+      "argsT": [
+        {
+          "name": "wrap_local_pos_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float wrap_local_pos_x=0.0f)",
+      "call_args": "(wrap_local_pos_x)",
+      "cimguiname": "igPushTextWrapPos",
+      "defaults": {
+        "wrap_local_pos_x": "0.0f"
+      },
+      "funcname": "PushTextWrapPos",
+      "location": "imgui:467",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igPushTextWrapPos",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igRadioButton": [
+    {
+      "args": "(const char* label,bool active)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "active",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool active)",
+      "call_args": "(label,active)",
+      "cimguiname": "igRadioButton",
+      "defaults": {},
+      "funcname": "RadioButton",
+      "location": "imgui:564",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRadioButton_Bool",
+      "ret": "bool",
+      "signature": "(const char*,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,int* v,int v_button)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int*"
+        },
+        {
+          "name": "v_button",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* v,int v_button)",
+      "call_args": "(label,v,v_button)",
+      "cimguiname": "igRadioButton",
+      "defaults": {},
+      "funcname": "RadioButton",
+      "location": "imgui:565",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRadioButton_IntPtr",
+      "ret": "bool",
+      "signature": "(const char*,int*,int)",
+      "stname": ""
+    }
+  ],
+  "igRemoveContextHook": [
+    {
+      "args": "(ImGuiContext* context,ImGuiID hook_to_remove)",
+      "argsT": [
+        {
+          "name": "context",
+          "type": "ImGuiContext*"
+        },
+        {
+          "name": "hook_to_remove",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* context,ImGuiID hook_to_remove)",
+      "call_args": "(context,hook_to_remove)",
+      "cimguiname": "igRemoveContextHook",
+      "defaults": {},
+      "funcname": "RemoveContextHook",
+      "location": "imgui_internal:3253",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRemoveContextHook",
+      "ret": "void",
+      "signature": "(ImGuiContext*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igRemoveSettingsHandler": [
+    {
+      "args": "(const char* type_name)",
+      "argsT": [
+        {
+          "name": "type_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* type_name)",
+      "call_args": "(type_name)",
+      "cimguiname": "igRemoveSettingsHandler",
+      "defaults": {},
+      "funcname": "RemoveSettingsHandler",
+      "location": "imgui_internal:3270",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRemoveSettingsHandler",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igRender": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igRender",
+      "defaults": {},
+      "funcname": "Render",
+      "location": "imgui:342",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRender",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igRenderArrow": [
+    {
+      "args": "(ImDrawList* draw_list,ImVec2 pos,ImU32 col,ImGuiDir dir,float scale)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "dir",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "scale",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImVec2 pos,ImU32 col,ImGuiDir dir,float scale=1.0f)",
+      "call_args": "(draw_list,pos,col,dir,scale)",
+      "cimguiname": "igRenderArrow",
+      "defaults": {
+        "scale": "1.0f"
+      },
+      "funcname": "RenderArrow",
+      "location": "imgui_internal:3682",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderArrow",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImU32,ImGuiDir,float)",
+      "stname": ""
+    }
+  ],
+  "igRenderArrowDockMenu": [
+    {
+      "args": "(ImDrawList* draw_list,ImVec2 p_min,float sz,ImU32 col)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p_min",
+          "type": "ImVec2"
+        },
+        {
+          "name": "sz",
+          "type": "float"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImVec2 p_min,float sz,ImU32 col)",
+      "call_args": "(draw_list,p_min,sz,col)",
+      "cimguiname": "igRenderArrowDockMenu",
+      "defaults": {},
+      "funcname": "RenderArrowDockMenu",
+      "location": "imgui_internal:3686",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderArrowDockMenu",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,float,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igRenderArrowPointingAt": [
+    {
+      "args": "(ImDrawList* draw_list,ImVec2 pos,ImVec2 half_sz,ImGuiDir direction,ImU32 col)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "half_sz",
+          "type": "ImVec2"
+        },
+        {
+          "name": "direction",
+          "type": "ImGuiDir"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImVec2 pos,ImVec2 half_sz,ImGuiDir direction,ImU32 col)",
+      "call_args": "(draw_list,pos,half_sz,direction,col)",
+      "cimguiname": "igRenderArrowPointingAt",
+      "defaults": {},
+      "funcname": "RenderArrowPointingAt",
+      "location": "imgui_internal:3685",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderArrowPointingAt",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImVec2,ImGuiDir,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igRenderBullet": [
+    {
+      "args": "(ImDrawList* draw_list,ImVec2 pos,ImU32 col)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImVec2 pos,ImU32 col)",
+      "call_args": "(draw_list,pos,col)",
+      "cimguiname": "igRenderBullet",
+      "defaults": {},
+      "funcname": "RenderBullet",
+      "location": "imgui_internal:3683",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderBullet",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igRenderCheckMark": [
+    {
+      "args": "(ImDrawList* draw_list,ImVec2 pos,ImU32 col,float sz)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "sz",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImVec2 pos,ImU32 col,float sz)",
+      "call_args": "(draw_list,pos,col,sz)",
+      "cimguiname": "igRenderCheckMark",
+      "defaults": {},
+      "funcname": "RenderCheckMark",
+      "location": "imgui_internal:3684",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderCheckMark",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImU32,float)",
+      "stname": ""
+    }
+  ],
+  "igRenderColorRectWithAlphaCheckerboard": [
+    {
+      "args": "(ImDrawList* draw_list,ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,float grid_step,ImVec2 grid_off,float rounding,ImDrawFlags flags)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "p_min",
+          "type": "ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "ImVec2"
+        },
+        {
+          "name": "fill_col",
+          "type": "ImU32"
+        },
+        {
+          "name": "grid_step",
+          "type": "float"
+        },
+        {
+          "name": "grid_off",
+          "type": "ImVec2"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImDrawFlags"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,float grid_step,ImVec2 grid_off,float rounding=0.0f,ImDrawFlags flags=0)",
+      "call_args": "(draw_list,p_min,p_max,fill_col,grid_step,grid_off,rounding,flags)",
+      "cimguiname": "igRenderColorRectWithAlphaCheckerboard",
+      "defaults": {
+        "flags": "0",
+        "rounding": "0.0f"
+      },
+      "funcname": "RenderColorRectWithAlphaCheckerboard",
+      "location": "imgui_internal:3673",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderColorRectWithAlphaCheckerboard",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImVec2,ImU32,float,ImVec2,float,ImDrawFlags)",
+      "stname": ""
+    }
+  ],
+  "igRenderDragDropTargetRect": [
+    {
+      "args": "(const ImRect bb,const ImRect item_clip_rect)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "item_clip_rect",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,const ImRect& item_clip_rect)",
+      "call_args": "(bb,item_clip_rect)",
+      "cimguiname": "igRenderDragDropTargetRect",
+      "defaults": {},
+      "funcname": "RenderDragDropTargetRect",
+      "location": "imgui_internal:3550",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderDragDropTargetRect",
+      "ret": "void",
+      "signature": "(const ImRect,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igRenderFrame": [
+    {
+      "args": "(ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,bool borders,float rounding)",
+      "argsT": [
+        {
+          "name": "p_min",
+          "type": "ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "ImVec2"
+        },
+        {
+          "name": "fill_col",
+          "type": "ImU32"
+        },
+        {
+          "name": "borders",
+          "type": "bool"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImVec2 p_min,ImVec2 p_max,ImU32 fill_col,bool borders=true,float rounding=0.0f)",
+      "call_args": "(p_min,p_max,fill_col,borders,rounding)",
+      "cimguiname": "igRenderFrame",
+      "defaults": {
+        "borders": "true",
+        "rounding": "0.0f"
+      },
+      "funcname": "RenderFrame",
+      "location": "imgui_internal:3671",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderFrame",
+      "ret": "void",
+      "signature": "(ImVec2,ImVec2,ImU32,bool,float)",
+      "stname": ""
+    }
+  ],
+  "igRenderFrameBorder": [
+    {
+      "args": "(ImVec2 p_min,ImVec2 p_max,float rounding)",
+      "argsT": [
+        {
+          "name": "p_min",
+          "type": "ImVec2"
+        },
+        {
+          "name": "p_max",
+          "type": "ImVec2"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImVec2 p_min,ImVec2 p_max,float rounding=0.0f)",
+      "call_args": "(p_min,p_max,rounding)",
+      "cimguiname": "igRenderFrameBorder",
+      "defaults": {
+        "rounding": "0.0f"
+      },
+      "funcname": "RenderFrameBorder",
+      "location": "imgui_internal:3672",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderFrameBorder",
+      "ret": "void",
+      "signature": "(ImVec2,ImVec2,float)",
+      "stname": ""
+    }
+  ],
+  "igRenderMouseCursor": [
+    {
+      "args": "(ImVec2 pos,float scale,ImGuiMouseCursor mouse_cursor,ImU32 col_fill,ImU32 col_border,ImU32 col_shadow)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "scale",
+          "type": "float"
+        },
+        {
+          "name": "mouse_cursor",
+          "type": "ImGuiMouseCursor"
+        },
+        {
+          "name": "col_fill",
+          "type": "ImU32"
+        },
+        {
+          "name": "col_border",
+          "type": "ImU32"
+        },
+        {
+          "name": "col_shadow",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImVec2 pos,float scale,ImGuiMouseCursor mouse_cursor,ImU32 col_fill,ImU32 col_border,ImU32 col_shadow)",
+      "call_args": "(pos,scale,mouse_cursor,col_fill,col_border,col_shadow)",
+      "cimguiname": "igRenderMouseCursor",
+      "defaults": {},
+      "funcname": "RenderMouseCursor",
+      "location": "imgui_internal:3679",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderMouseCursor",
+      "ret": "void",
+      "signature": "(ImVec2,float,ImGuiMouseCursor,ImU32,ImU32,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igRenderNavCursor": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,ImGuiNavRenderCursorFlags flags)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiNavRenderCursorFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,ImGuiNavRenderCursorFlags flags=ImGuiNavRenderCursorFlags_None)",
+      "call_args": "(bb,id,flags)",
+      "cimguiname": "igRenderNavCursor",
+      "defaults": {
+        "flags": "ImGuiNavRenderCursorFlags_None"
+      },
+      "funcname": "RenderNavCursor",
+      "location": "imgui_internal:3674",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderNavCursor",
+      "ret": "void",
+      "signature": "(const ImRect,ImGuiID,ImGuiNavRenderCursorFlags)",
+      "stname": ""
+    }
+  ],
+  "igRenderPlatformWindowsDefault": [
+    {
+      "args": "(void* platform_render_arg,void* renderer_render_arg)",
+      "argsT": [
+        {
+          "name": "platform_render_arg",
+          "type": "void*"
+        },
+        {
+          "name": "renderer_render_arg",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(void* platform_render_arg=((void*)0),void* renderer_render_arg=((void*)0))",
+      "call_args": "(platform_render_arg,renderer_render_arg)",
+      "cimguiname": "igRenderPlatformWindowsDefault",
+      "defaults": {
+        "platform_render_arg": "NULL",
+        "renderer_render_arg": "NULL"
+      },
+      "funcname": "RenderPlatformWindowsDefault",
+      "location": "imgui:1089",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderPlatformWindowsDefault",
+      "ret": "void",
+      "signature": "(void*,void*)",
+      "stname": ""
+    }
+  ],
+  "igRenderRectFilledRangeH": [
+    {
+      "args": "(ImDrawList* draw_list,const ImRect rect,ImU32 col,float x_start_norm,float x_end_norm,float rounding)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "rect",
+          "type": "const ImRect"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "x_start_norm",
+          "type": "float"
+        },
+        {
+          "name": "x_end_norm",
+          "type": "float"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,const ImRect& rect,ImU32 col,float x_start_norm,float x_end_norm,float rounding)",
+      "call_args": "(draw_list,rect,col,x_start_norm,x_end_norm,rounding)",
+      "cimguiname": "igRenderRectFilledRangeH",
+      "defaults": {},
+      "funcname": "RenderRectFilledRangeH",
+      "location": "imgui_internal:3687",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderRectFilledRangeH",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImRect,ImU32,float,float,float)",
+      "stname": ""
+    }
+  ],
+  "igRenderRectFilledWithHole": [
+    {
+      "args": "(ImDrawList* draw_list,const ImRect outer,const ImRect inner,ImU32 col,float rounding)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "outer",
+          "type": "const ImRect"
+        },
+        {
+          "name": "inner",
+          "type": "const ImRect"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "rounding",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,const ImRect& outer,const ImRect& inner,ImU32 col,float rounding)",
+      "call_args": "(draw_list,outer,inner,col,rounding)",
+      "cimguiname": "igRenderRectFilledWithHole",
+      "defaults": {},
+      "funcname": "RenderRectFilledWithHole",
+      "location": "imgui_internal:3688",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderRectFilledWithHole",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImRect,const ImRect,ImU32,float)",
+      "stname": ""
+    }
+  ],
+  "igRenderText": [
+    {
+      "args": "(ImVec2 pos,const char* text,const char* text_end,bool hide_text_after_hash)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "hide_text_after_hash",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImVec2 pos,const char* text,const char* text_end=((void*)0),bool hide_text_after_hash=true)",
+      "call_args": "(pos,text,text_end,hide_text_after_hash)",
+      "cimguiname": "igRenderText",
+      "defaults": {
+        "hide_text_after_hash": "true",
+        "text_end": "NULL"
+      },
+      "funcname": "RenderText",
+      "location": "imgui_internal:3666",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderText",
+      "ret": "void",
+      "signature": "(ImVec2,const char*,const char*,bool)",
+      "stname": ""
+    }
+  ],
+  "igRenderTextClipped": [
+    {
+      "args": "(const ImVec2 pos_min,const ImVec2 pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2 align,const ImRect* clip_rect)",
+      "argsT": [
+        {
+          "name": "pos_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "pos_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "text_size_if_known",
+          "type": "const ImVec2*"
+        },
+        {
+          "name": "align",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clip_rect",
+          "type": "const ImRect*"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos_min,const ImVec2& pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2& align=ImVec2(0,0),const ImRect* clip_rect=((void*)0))",
+      "call_args": "(pos_min,pos_max,text,text_end,text_size_if_known,align,clip_rect)",
+      "cimguiname": "igRenderTextClipped",
+      "defaults": {
+        "align": "ImVec2(0,0)",
+        "clip_rect": "NULL"
+      },
+      "funcname": "RenderTextClipped",
+      "location": "imgui_internal:3668",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderTextClipped",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const char*,const char*,const ImVec2*,const ImVec2,const ImRect*)",
+      "stname": ""
+    }
+  ],
+  "igRenderTextClippedEx": [
+    {
+      "args": "(ImDrawList* draw_list,const ImVec2 pos_min,const ImVec2 pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2 align,const ImRect* clip_rect)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "pos_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "text_size_if_known",
+          "type": "const ImVec2*"
+        },
+        {
+          "name": "align",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clip_rect",
+          "type": "const ImRect*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,const ImVec2& pos_min,const ImVec2& pos_max,const char* text,const char* text_end,const ImVec2* text_size_if_known,const ImVec2& align=ImVec2(0,0),const ImRect* clip_rect=((void*)0))",
+      "call_args": "(draw_list,pos_min,pos_max,text,text_end,text_size_if_known,align,clip_rect)",
+      "cimguiname": "igRenderTextClippedEx",
+      "defaults": {
+        "align": "ImVec2(0,0)",
+        "clip_rect": "NULL"
+      },
+      "funcname": "RenderTextClippedEx",
+      "location": "imgui_internal:3669",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderTextClippedEx",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImVec2,const ImVec2,const char*,const char*,const ImVec2*,const ImVec2,const ImRect*)",
+      "stname": ""
+    }
+  ],
+  "igRenderTextEllipsis": [
+    {
+      "args": "(ImDrawList* draw_list,const ImVec2 pos_min,const ImVec2 pos_max,float clip_max_x,float ellipsis_max_x,const char* text,const char* text_end,const ImVec2* text_size_if_known)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "pos_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clip_max_x",
+          "type": "float"
+        },
+        {
+          "name": "ellipsis_max_x",
+          "type": "float"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "text_size_if_known",
+          "type": "const ImVec2*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,const ImVec2& pos_min,const ImVec2& pos_max,float clip_max_x,float ellipsis_max_x,const char* text,const char* text_end,const ImVec2* text_size_if_known)",
+      "call_args": "(draw_list,pos_min,pos_max,clip_max_x,ellipsis_max_x,text,text_end,text_size_if_known)",
+      "cimguiname": "igRenderTextEllipsis",
+      "defaults": {},
+      "funcname": "RenderTextEllipsis",
+      "location": "imgui_internal:3670",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderTextEllipsis",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImVec2,const ImVec2,float,float,const char*,const char*,const ImVec2*)",
+      "stname": ""
+    }
+  ],
+  "igRenderTextWrapped": [
+    {
+      "args": "(ImVec2 pos,const char* text,const char* text_end,float wrap_width)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "wrap_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImVec2 pos,const char* text,const char* text_end,float wrap_width)",
+      "call_args": "(pos,text,text_end,wrap_width)",
+      "cimguiname": "igRenderTextWrapped",
+      "defaults": {},
+      "funcname": "RenderTextWrapped",
+      "location": "imgui_internal:3667",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igRenderTextWrapped",
+      "ret": "void",
+      "signature": "(ImVec2,const char*,const char*,float)",
+      "stname": ""
+    }
+  ],
+  "igResetMouseDragDelta": [
+    {
+      "args": "(ImGuiMouseButton button)",
+      "argsT": [
+        {
+          "name": "button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseButton button=0)",
+      "call_args": "(button)",
+      "cimguiname": "igResetMouseDragDelta",
+      "defaults": {
+        "button": "0"
+      },
+      "funcname": "ResetMouseDragDelta",
+      "location": "imgui:1046",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igResetMouseDragDelta",
+      "ret": "void",
+      "signature": "(ImGuiMouseButton)",
+      "stname": ""
+    }
+  ],
+  "igSameLine": [
+    {
+      "args": "(float offset_from_start_x,float spacing)",
+      "argsT": [
+        {
+          "name": "offset_from_start_x",
+          "type": "float"
+        },
+        {
+          "name": "spacing",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float offset_from_start_x=0.0f,float spacing=-1.0f)",
+      "call_args": "(offset_from_start_x,spacing)",
+      "cimguiname": "igSameLine",
+      "defaults": {
+        "offset_from_start_x": "0.0f",
+        "spacing": "-1.0f"
+      },
+      "funcname": "SameLine",
+      "location": "imgui:503",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSameLine",
+      "ret": "void",
+      "signature": "(float,float)",
+      "stname": ""
+    }
+  ],
+  "igSaveIniSettingsToDisk": [
+    {
+      "args": "(const char* ini_filename)",
+      "argsT": [
+        {
+          "name": "ini_filename",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* ini_filename)",
+      "call_args": "(ini_filename)",
+      "cimguiname": "igSaveIniSettingsToDisk",
+      "defaults": {},
+      "funcname": "SaveIniSettingsToDisk",
+      "location": "imgui:1062",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSaveIniSettingsToDisk",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igSaveIniSettingsToMemory": [
+    {
+      "args": "(size_t* out_ini_size)",
+      "argsT": [
+        {
+          "name": "out_ini_size",
+          "type": "size_t*"
+        }
+      ],
+      "argsoriginal": "(size_t* out_ini_size=((void*)0))",
+      "call_args": "(out_ini_size)",
+      "cimguiname": "igSaveIniSettingsToMemory",
+      "defaults": {
+        "out_ini_size": "NULL"
+      },
+      "funcname": "SaveIniSettingsToMemory",
+      "location": "imgui:1063",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSaveIniSettingsToMemory",
+      "ret": "const char*",
+      "signature": "(size_t*)",
+      "stname": ""
+    }
+  ],
+  "igScaleWindowsInViewport": [
+    {
+      "args": "(ImGuiViewportP* viewport,float scale)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        },
+        {
+          "name": "scale",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewportP* viewport,float scale)",
+      "call_args": "(viewport,scale)",
+      "cimguiname": "igScaleWindowsInViewport",
+      "defaults": {},
+      "funcname": "ScaleWindowsInViewport",
+      "location": "imgui_internal:3258",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igScaleWindowsInViewport",
+      "ret": "void",
+      "signature": "(ImGuiViewportP*,float)",
+      "stname": ""
+    }
+  ],
+  "igScrollToBringRectIntoView": [
+    {
+      "args": "(ImGuiWindow* window,const ImRect rect)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "rect",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImRect& rect)",
+      "call_args": "(window,rect)",
+      "cimguiname": "igScrollToBringRectIntoView",
+      "defaults": {},
+      "funcname": "ScrollToBringRectIntoView",
+      "location": "imgui_internal:3294",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igScrollToBringRectIntoView",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igScrollToItem": [
+    {
+      "args": "(ImGuiScrollFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiScrollFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiScrollFlags flags=0)",
+      "call_args": "(flags)",
+      "cimguiname": "igScrollToItem",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ScrollToItem",
+      "location": "imgui_internal:3290",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igScrollToItem",
+      "ret": "void",
+      "signature": "(ImGuiScrollFlags)",
+      "stname": ""
+    }
+  ],
+  "igScrollToRect": [
+    {
+      "args": "(ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "rect",
+          "type": "const ImRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiScrollFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImRect& rect,ImGuiScrollFlags flags=0)",
+      "call_args": "(window,rect,flags)",
+      "cimguiname": "igScrollToRect",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ScrollToRect",
+      "location": "imgui_internal:3291",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igScrollToRect",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImRect,ImGuiScrollFlags)",
+      "stname": ""
+    }
+  ],
+  "igScrollToRectEx": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "rect",
+          "type": "const ImRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiScrollFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImRect& rect,ImGuiScrollFlags flags=0)",
+      "call_args": "(window,rect,flags)",
+      "cimguiname": "igScrollToRectEx",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "ScrollToRectEx",
+      "location": "imgui_internal:3292",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igScrollToRectEx",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImRect,ImGuiScrollFlags)",
+      "stname": ""
+    }
+  ],
+  "igScrollbar": [
+    {
+      "args": "(ImGuiAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        }
+      ],
+      "argsoriginal": "(ImGuiAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "igScrollbar",
+      "defaults": {},
+      "funcname": "Scrollbar",
+      "location": "imgui_internal:3704",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igScrollbar",
+      "ret": "void",
+      "signature": "(ImGuiAxis)",
+      "stname": ""
+    }
+  ],
+  "igScrollbarEx": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags draw_rounding_flags)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        },
+        {
+          "name": "p_scroll_v",
+          "type": "ImS64*"
+        },
+        {
+          "name": "avail_v",
+          "type": "ImS64"
+        },
+        {
+          "name": "contents_v",
+          "type": "ImS64"
+        },
+        {
+          "name": "draw_rounding_flags",
+          "type": "ImDrawFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags draw_rounding_flags=0)",
+      "call_args": "(bb,id,axis,p_scroll_v,avail_v,contents_v,draw_rounding_flags)",
+      "cimguiname": "igScrollbarEx",
+      "defaults": {
+        "draw_rounding_flags": "0"
+      },
+      "funcname": "ScrollbarEx",
+      "location": "imgui_internal:3705",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igScrollbarEx",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,ImGuiAxis,ImS64*,ImS64,ImS64,ImDrawFlags)",
+      "stname": ""
+    }
+  ],
+  "igSelectable": [
+    {
+      "args": "(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "selected",
+          "type": "bool"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSelectableFlags"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool selected=false,ImGuiSelectableFlags flags=0,const ImVec2& size=ImVec2(0,0))",
+      "call_args": "(label,selected,flags,size)",
+      "cimguiname": "igSelectable",
+      "defaults": {
+        "flags": "0",
+        "selected": "false",
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "Selectable",
+      "location": "imgui:686",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSelectable_Bool",
+      "ret": "bool",
+      "signature": "(const char*,bool,ImGuiSelectableFlags,const ImVec2)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label,bool* p_selected,ImGuiSelectableFlags flags,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "p_selected",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSelectableFlags"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool* p_selected,ImGuiSelectableFlags flags=0,const ImVec2& size=ImVec2(0,0))",
+      "call_args": "(label,p_selected,flags,size)",
+      "cimguiname": "igSelectable",
+      "defaults": {
+        "flags": "0",
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "Selectable",
+      "location": "imgui:687",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSelectable_BoolPtr",
+      "ret": "bool",
+      "signature": "(const char*,bool*,ImGuiSelectableFlags,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSeparator": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSeparator",
+      "defaults": {},
+      "funcname": "Separator",
+      "location": "imgui:502",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSeparator",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSeparatorEx": [
+    {
+      "args": "(ImGuiSeparatorFlags flags,float thickness)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiSeparatorFlags"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiSeparatorFlags flags,float thickness=1.0f)",
+      "call_args": "(flags,thickness)",
+      "cimguiname": "igSeparatorEx",
+      "defaults": {
+        "thickness": "1.0f"
+      },
+      "funcname": "SeparatorEx",
+      "location": "imgui_internal:3696",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSeparatorEx",
+      "ret": "void",
+      "signature": "(ImGuiSeparatorFlags,float)",
+      "stname": ""
+    }
+  ],
+  "igSeparatorText": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igSeparatorText",
+      "defaults": {},
+      "funcname": "SeparatorText",
+      "location": "imgui:552",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSeparatorText",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igSeparatorTextEx": [
+    {
+      "args": "(ImGuiID id,const char* label,const char* label_end,float extra_width)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "label_end",
+          "type": "const char*"
+        },
+        {
+          "name": "extra_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,const char* label,const char* label_end,float extra_width)",
+      "call_args": "(id,label,label_end,extra_width)",
+      "cimguiname": "igSeparatorTextEx",
+      "defaults": {},
+      "funcname": "SeparatorTextEx",
+      "location": "imgui_internal:3697",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSeparatorTextEx",
+      "ret": "void",
+      "signature": "(ImGuiID,const char*,const char*,float)",
+      "stname": ""
+    }
+  ],
+  "igSetActiveID": [
+    {
+      "args": "(ImGuiID id,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiWindow* window)",
+      "call_args": "(id,window)",
+      "cimguiname": "igSetActiveID",
+      "defaults": {},
+      "funcname": "SetActiveID",
+      "location": "imgui_internal:3302",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetActiveID",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igSetActiveIdUsingAllKeyboardKeys": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSetActiveIdUsingAllKeyboardKeys",
+      "defaults": {},
+      "funcname": "SetActiveIdUsingAllKeyboardKeys",
+      "location": "imgui_internal:3423",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetActiveIdUsingAllKeyboardKeys",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSetAllocatorFunctions": [
+    {
+      "args": "(ImGuiMemAllocFunc alloc_func,ImGuiMemFreeFunc free_func,void* user_data)",
+      "argsT": [
+        {
+          "name": "alloc_func",
+          "type": "ImGuiMemAllocFunc"
+        },
+        {
+          "name": "free_func",
+          "type": "ImGuiMemFreeFunc"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiMemAllocFunc alloc_func,ImGuiMemFreeFunc free_func,void* user_data=((void*)0))",
+      "call_args": "(alloc_func,free_func,user_data)",
+      "cimguiname": "igSetAllocatorFunctions",
+      "defaults": {
+        "user_data": "NULL"
+      },
+      "funcname": "SetAllocatorFunctions",
+      "location": "imgui:1080",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetAllocatorFunctions",
+      "ret": "void",
+      "signature": "(ImGuiMemAllocFunc,ImGuiMemFreeFunc,void*)",
+      "stname": ""
+    }
+  ],
+  "igSetClipboardText": [
+    {
+      "args": "(const char* text)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text)",
+      "call_args": "(text)",
+      "cimguiname": "igSetClipboardText",
+      "defaults": {},
+      "funcname": "SetClipboardText",
+      "location": "imgui:1054",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetClipboardText",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igSetColorEditOptions": [
+    {
+      "args": "(ImGuiColorEditFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiColorEditFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiColorEditFlags flags)",
+      "call_args": "(flags)",
+      "cimguiname": "igSetColorEditOptions",
+      "defaults": {},
+      "funcname": "SetColorEditOptions",
+      "location": "imgui:660",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetColorEditOptions",
+      "ret": "void",
+      "signature": "(ImGuiColorEditFlags)",
+      "stname": ""
+    }
+  ],
+  "igSetColumnOffset": [
+    {
+      "args": "(int column_index,float offset_x)",
+      "argsT": [
+        {
+          "name": "column_index",
+          "type": "int"
+        },
+        {
+          "name": "offset_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(int column_index,float offset_x)",
+      "call_args": "(column_index,offset_x)",
+      "cimguiname": "igSetColumnOffset",
+      "defaults": {},
+      "funcname": "SetColumnOffset",
+      "location": "imgui:864",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetColumnOffset",
+      "ret": "void",
+      "signature": "(int,float)",
+      "stname": ""
+    }
+  ],
+  "igSetColumnWidth": [
+    {
+      "args": "(int column_index,float width)",
+      "argsT": [
+        {
+          "name": "column_index",
+          "type": "int"
+        },
+        {
+          "name": "width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(int column_index,float width)",
+      "call_args": "(column_index,width)",
+      "cimguiname": "igSetColumnWidth",
+      "defaults": {},
+      "funcname": "SetColumnWidth",
+      "location": "imgui:862",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetColumnWidth",
+      "ret": "void",
+      "signature": "(int,float)",
+      "stname": ""
+    }
+  ],
+  "igSetCurrentContext": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "igSetCurrentContext",
+      "defaults": {},
+      "funcname": "SetCurrentContext",
+      "location": "imgui:334",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCurrentContext",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "igSetCurrentFont": [
+    {
+      "args": "(ImFont* font)",
+      "argsT": [
+        {
+          "name": "font",
+          "type": "ImFont*"
+        }
+      ],
+      "argsoriginal": "(ImFont* font)",
+      "call_args": "(font)",
+      "cimguiname": "igSetCurrentFont",
+      "defaults": {},
+      "funcname": "SetCurrentFont",
+      "location": "imgui_internal:3233",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCurrentFont",
+      "ret": "void",
+      "signature": "(ImFont*)",
+      "stname": ""
+    }
+  ],
+  "igSetCurrentViewport": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiViewportP* viewport)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiViewportP* viewport)",
+      "call_args": "(window,viewport)",
+      "cimguiname": "igSetCurrentViewport",
+      "defaults": {},
+      "funcname": "SetCurrentViewport",
+      "location": "imgui_internal:3261",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCurrentViewport",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiViewportP*)",
+      "stname": ""
+    }
+  ],
+  "igSetCursorPos": [
+    {
+      "args": "(const ImVec2 local_pos)",
+      "argsT": [
+        {
+          "name": "local_pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& local_pos)",
+      "call_args": "(local_pos)",
+      "cimguiname": "igSetCursorPos",
+      "defaults": {},
+      "funcname": "SetCursorPos",
+      "location": "imgui:496",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCursorPos",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSetCursorPosX": [
+    {
+      "args": "(float local_x)",
+      "argsT": [
+        {
+          "name": "local_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float local_x)",
+      "call_args": "(local_x)",
+      "cimguiname": "igSetCursorPosX",
+      "defaults": {},
+      "funcname": "SetCursorPosX",
+      "location": "imgui:497",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCursorPosX",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetCursorPosY": [
+    {
+      "args": "(float local_y)",
+      "argsT": [
+        {
+          "name": "local_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float local_y)",
+      "call_args": "(local_y)",
+      "cimguiname": "igSetCursorPosY",
+      "defaults": {},
+      "funcname": "SetCursorPosY",
+      "location": "imgui:498",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCursorPosY",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetCursorScreenPos": [
+    {
+      "args": "(const ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos)",
+      "call_args": "(pos)",
+      "cimguiname": "igSetCursorScreenPos",
+      "defaults": {},
+      "funcname": "SetCursorScreenPos",
+      "location": "imgui:491",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetCursorScreenPos",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSetDragDropPayload": [
+    {
+      "args": "(const char* type,const void* data,size_t sz,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "type",
+          "type": "const char*"
+        },
+        {
+          "name": "data",
+          "type": "const void*"
+        },
+        {
+          "name": "sz",
+          "type": "size_t"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const char* type,const void* data,size_t sz,ImGuiCond cond=0)",
+      "call_args": "(type,data,sz,cond)",
+      "cimguiname": "igSetDragDropPayload",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetDragDropPayload",
+      "location": "imgui:912",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetDragDropPayload",
+      "ret": "bool",
+      "signature": "(const char*,const void*,size_t,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetFocusID": [
+    {
+      "args": "(ImGuiID id,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiWindow* window)",
+      "call_args": "(id,window)",
+      "cimguiname": "igSetFocusID",
+      "defaults": {},
+      "funcname": "SetFocusID",
+      "location": "imgui_internal:3303",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetFocusID",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igSetHoveredID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igSetHoveredID",
+      "defaults": {},
+      "funcname": "SetHoveredID",
+      "location": "imgui_internal:3306",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetHoveredID",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igSetItemDefaultFocus": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSetItemDefaultFocus",
+      "defaults": {},
+      "funcname": "SetItemDefaultFocus",
+      "location": "imgui:933",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetItemDefaultFocus",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSetItemKeyOwner": [
+    {
+      "args": "(ImGuiKey key)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key)",
+      "call_args": "(key)",
+      "cimguiname": "igSetItemKeyOwner",
+      "defaults": {},
+      "funcname": "SetItemKeyOwner",
+      "location": "imgui:1028",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetItemKeyOwner_Nil",
+      "ret": "void",
+      "signature": "(ImGuiKey)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKey key,ImGuiInputFlags flags)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,ImGuiInputFlags flags)",
+      "call_args": "(key,flags)",
+      "cimguiname": "igSetItemKeyOwner",
+      "defaults": {},
+      "funcname": "SetItemKeyOwner",
+      "location": "imgui_internal:3440",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetItemKeyOwner_InputFlags",
+      "ret": "void",
+      "signature": "(ImGuiKey,ImGuiInputFlags)",
+      "stname": ""
+    }
+  ],
+  "igSetItemTooltip": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igSetItemTooltip",
+      "defaults": {},
+      "funcname": "SetItemTooltip",
+      "isvararg": "...)",
+      "location": "imgui:754",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetItemTooltip",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igSetItemTooltipV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igSetItemTooltipV",
+      "defaults": {},
+      "funcname": "SetItemTooltipV",
+      "location": "imgui:755",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetItemTooltipV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igSetKeyOwner": [
+    {
+      "args": "(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,ImGuiID owner_id,ImGuiInputFlags flags=0)",
+      "call_args": "(key,owner_id,flags)",
+      "cimguiname": "igSetKeyOwner",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "SetKeyOwner",
+      "location": "imgui_internal:3438",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetKeyOwner",
+      "ret": "void",
+      "signature": "(ImGuiKey,ImGuiID,ImGuiInputFlags)",
+      "stname": ""
+    }
+  ],
+  "igSetKeyOwnersForKeyChord": [
+    {
+      "args": "(ImGuiKeyChord key,ImGuiID owner_id,ImGuiInputFlags flags)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key,ImGuiID owner_id,ImGuiInputFlags flags=0)",
+      "call_args": "(key,owner_id,flags)",
+      "cimguiname": "igSetKeyOwnersForKeyChord",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "SetKeyOwnersForKeyChord",
+      "location": "imgui_internal:3439",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetKeyOwnersForKeyChord",
+      "ret": "void",
+      "signature": "(ImGuiKeyChord,ImGuiID,ImGuiInputFlags)",
+      "stname": ""
+    }
+  ],
+  "igSetKeyboardFocusHere": [
+    {
+      "args": "(int offset)",
+      "argsT": [
+        {
+          "name": "offset",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int offset=0)",
+      "call_args": "(offset)",
+      "cimguiname": "igSetKeyboardFocusHere",
+      "defaults": {
+        "offset": "0"
+      },
+      "funcname": "SetKeyboardFocusHere",
+      "location": "imgui:934",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetKeyboardFocusHere",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igSetLastItemData": [
+    {
+      "args": "(ImGuiID item_id,ImGuiItemFlags in_flags,ImGuiItemStatusFlags status_flags,const ImRect item_rect)",
+      "argsT": [
+        {
+          "name": "item_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "in_flags",
+          "type": "ImGuiItemFlags"
+        },
+        {
+          "name": "status_flags",
+          "type": "ImGuiItemStatusFlags"
+        },
+        {
+          "name": "item_rect",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImGuiID item_id,ImGuiItemFlags in_flags,ImGuiItemStatusFlags status_flags,const ImRect& item_rect)",
+      "call_args": "(item_id,in_flags,status_flags,item_rect)",
+      "cimguiname": "igSetLastItemData",
+      "defaults": {},
+      "funcname": "SetLastItemData",
+      "location": "imgui_internal:3320",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetLastItemData",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiItemFlags,ImGuiItemStatusFlags,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igSetMouseCursor": [
+    {
+      "args": "(ImGuiMouseCursor cursor_type)",
+      "argsT": [
+        {
+          "name": "cursor_type",
+          "type": "ImGuiMouseCursor"
+        }
+      ],
+      "argsoriginal": "(ImGuiMouseCursor cursor_type)",
+      "call_args": "(cursor_type)",
+      "cimguiname": "igSetMouseCursor",
+      "defaults": {},
+      "funcname": "SetMouseCursor",
+      "location": "imgui:1048",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetMouseCursor",
+      "ret": "void",
+      "signature": "(ImGuiMouseCursor)",
+      "stname": ""
+    }
+  ],
+  "igSetNavCursorVisible": [
+    {
+      "args": "(bool visible)",
+      "argsT": [
+        {
+          "name": "visible",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool visible)",
+      "call_args": "(visible)",
+      "cimguiname": "igSetNavCursorVisible",
+      "defaults": {},
+      "funcname": "SetNavCursorVisible",
+      "location": "imgui:937",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNavCursorVisible",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "igSetNavCursorVisibleAfterMove": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSetNavCursorVisibleAfterMove",
+      "defaults": {},
+      "funcname": "SetNavCursorVisibleAfterMove",
+      "location": "imgui_internal:3381",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNavCursorVisibleAfterMove",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSetNavFocusScope": [
+    {
+      "args": "(ImGuiID focus_scope_id)",
+      "argsT": [
+        {
+          "name": "focus_scope_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID focus_scope_id)",
+      "call_args": "(focus_scope_id)",
+      "cimguiname": "igSetNavFocusScope",
+      "defaults": {},
+      "funcname": "SetNavFocusScope",
+      "location": "imgui_internal:3385",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNavFocusScope",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igSetNavID": [
+    {
+      "args": "(ImGuiID id,ImGuiNavLayer nav_layer,ImGuiID focus_scope_id,const ImRect rect_rel)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "nav_layer",
+          "type": "ImGuiNavLayer"
+        },
+        {
+          "name": "focus_scope_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "rect_rel",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiNavLayer nav_layer,ImGuiID focus_scope_id,const ImRect& rect_rel)",
+      "call_args": "(id,nav_layer,focus_scope_id,rect_rel)",
+      "cimguiname": "igSetNavID",
+      "defaults": {},
+      "funcname": "SetNavID",
+      "location": "imgui_internal:3384",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNavID",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiNavLayer,ImGuiID,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igSetNavWindow": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igSetNavWindow",
+      "defaults": {},
+      "funcname": "SetNavWindow",
+      "location": "imgui_internal:3383",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNavWindow",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igSetNextFrameWantCaptureKeyboard": [
+    {
+      "args": "(bool want_capture_keyboard)",
+      "argsT": [
+        {
+          "name": "want_capture_keyboard",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool want_capture_keyboard)",
+      "call_args": "(want_capture_keyboard)",
+      "cimguiname": "igSetNextFrameWantCaptureKeyboard",
+      "defaults": {},
+      "funcname": "SetNextFrameWantCaptureKeyboard",
+      "location": "imgui:1002",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextFrameWantCaptureKeyboard",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "igSetNextFrameWantCaptureMouse": [
+    {
+      "args": "(bool want_capture_mouse)",
+      "argsT": [
+        {
+          "name": "want_capture_mouse",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool want_capture_mouse)",
+      "call_args": "(want_capture_mouse)",
+      "cimguiname": "igSetNextFrameWantCaptureMouse",
+      "defaults": {},
+      "funcname": "SetNextFrameWantCaptureMouse",
+      "location": "imgui:1049",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextFrameWantCaptureMouse",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemAllowOverlap": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSetNextItemAllowOverlap",
+      "defaults": {},
+      "funcname": "SetNextItemAllowOverlap",
+      "location": "imgui:940",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemAllowOverlap",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemOpen": [
+    {
+      "args": "(bool is_open,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "is_open",
+          "type": "bool"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(bool is_open,ImGuiCond cond=0)",
+      "call_args": "(is_open,cond)",
+      "cimguiname": "igSetNextItemOpen",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetNextItemOpen",
+      "location": "imgui:680",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemOpen",
+      "ret": "void",
+      "signature": "(bool,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemRefVal": [
+    {
+      "args": "(ImGuiDataType data_type,void* p_data)",
+      "argsT": [
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiDataType data_type,void* p_data)",
+      "call_args": "(data_type,p_data)",
+      "cimguiname": "igSetNextItemRefVal",
+      "defaults": {},
+      "funcname": "SetNextItemRefVal",
+      "location": "imgui_internal:3750",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemRefVal",
+      "ret": "void",
+      "signature": "(ImGuiDataType,void*)",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemSelectionUserData": [
+    {
+      "args": "(ImGuiSelectionUserData selection_user_data)",
+      "argsT": [
+        {
+          "name": "selection_user_data",
+          "type": "ImGuiSelectionUserData"
+        }
+      ],
+      "argsoriginal": "(ImGuiSelectionUserData selection_user_data)",
+      "call_args": "(selection_user_data)",
+      "cimguiname": "igSetNextItemSelectionUserData",
+      "defaults": {},
+      "funcname": "SetNextItemSelectionUserData",
+      "location": "imgui:698",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemSelectionUserData",
+      "ret": "void",
+      "signature": "(ImGuiSelectionUserData)",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemShortcut": [
+    {
+      "args": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags=0)",
+      "call_args": "(key_chord,flags)",
+      "cimguiname": "igSetNextItemShortcut",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "SetNextItemShortcut",
+      "location": "imgui:1020",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemShortcut",
+      "ret": "void",
+      "signature": "(ImGuiKeyChord,ImGuiInputFlags)",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemStorageID": [
+    {
+      "args": "(ImGuiID storage_id)",
+      "argsT": [
+        {
+          "name": "storage_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID storage_id)",
+      "call_args": "(storage_id)",
+      "cimguiname": "igSetNextItemStorageID",
+      "defaults": {},
+      "funcname": "SetNextItemStorageID",
+      "location": "imgui:681",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemStorageID",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igSetNextItemWidth": [
+    {
+      "args": "(float item_width)",
+      "argsT": [
+        {
+          "name": "item_width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float item_width)",
+      "call_args": "(item_width)",
+      "cimguiname": "igSetNextItemWidth",
+      "defaults": {},
+      "funcname": "SetNextItemWidth",
+      "location": "imgui:465",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextItemWidth",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowBgAlpha": [
+    {
+      "args": "(float alpha)",
+      "argsT": [
+        {
+          "name": "alpha",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float alpha)",
+      "call_args": "(alpha)",
+      "cimguiname": "igSetNextWindowBgAlpha",
+      "defaults": {},
+      "funcname": "SetNextWindowBgAlpha",
+      "location": "imgui:422",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowBgAlpha",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowClass": [
+    {
+      "args": "(const ImGuiWindowClass* window_class)",
+      "argsT": [
+        {
+          "name": "window_class",
+          "type": "const ImGuiWindowClass*"
+        }
+      ],
+      "argsoriginal": "(const ImGuiWindowClass* window_class)",
+      "call_args": "(window_class)",
+      "cimguiname": "igSetNextWindowClass",
+      "defaults": {},
+      "funcname": "SetNextWindowClass",
+      "location": "imgui:892",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowClass",
+      "ret": "void",
+      "signature": "(const ImGuiWindowClass*)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowCollapsed": [
+    {
+      "args": "(bool collapsed,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "collapsed",
+          "type": "bool"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(bool collapsed,ImGuiCond cond=0)",
+      "call_args": "(collapsed,cond)",
+      "cimguiname": "igSetNextWindowCollapsed",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetNextWindowCollapsed",
+      "location": "imgui:419",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowCollapsed",
+      "ret": "void",
+      "signature": "(bool,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowContentSize": [
+    {
+      "args": "(const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size)",
+      "call_args": "(size)",
+      "cimguiname": "igSetNextWindowContentSize",
+      "defaults": {},
+      "funcname": "SetNextWindowContentSize",
+      "location": "imgui:418",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowContentSize",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowDockID": [
+    {
+      "args": "(ImGuiID dock_id,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "dock_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(ImGuiID dock_id,ImGuiCond cond=0)",
+      "call_args": "(dock_id,cond)",
+      "cimguiname": "igSetNextWindowDockID",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetNextWindowDockID",
+      "location": "imgui:891",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowDockID",
+      "ret": "void",
+      "signature": "(ImGuiID,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowFocus": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSetNextWindowFocus",
+      "defaults": {},
+      "funcname": "SetNextWindowFocus",
+      "location": "imgui:420",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowFocus",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowPos": [
+    {
+      "args": "(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        },
+        {
+          "name": "pivot",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,ImGuiCond cond=0,const ImVec2& pivot=ImVec2(0,0))",
+      "call_args": "(pos,cond,pivot)",
+      "cimguiname": "igSetNextWindowPos",
+      "defaults": {
+        "cond": "0",
+        "pivot": "ImVec2(0,0)"
+      },
+      "funcname": "SetNextWindowPos",
+      "location": "imgui:415",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowPos",
+      "ret": "void",
+      "signature": "(const ImVec2,ImGuiCond,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowRefreshPolicy": [
+    {
+      "args": "(ImGuiWindowRefreshFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiWindowRefreshFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindowRefreshFlags flags)",
+      "call_args": "(flags)",
+      "cimguiname": "igSetNextWindowRefreshPolicy",
+      "defaults": {},
+      "funcname": "SetNextWindowRefreshPolicy",
+      "location": "imgui_internal:3230",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowRefreshPolicy",
+      "ret": "void",
+      "signature": "(ImGuiWindowRefreshFlags)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowScroll": [
+    {
+      "args": "(const ImVec2 scroll)",
+      "argsT": [
+        {
+          "name": "scroll",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& scroll)",
+      "call_args": "(scroll)",
+      "cimguiname": "igSetNextWindowScroll",
+      "defaults": {},
+      "funcname": "SetNextWindowScroll",
+      "location": "imgui:421",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowScroll",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowSize": [
+    {
+      "args": "(const ImVec2 size,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size,ImGuiCond cond=0)",
+      "call_args": "(size,cond)",
+      "cimguiname": "igSetNextWindowSize",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetNextWindowSize",
+      "location": "imgui:416",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowSize",
+      "ret": "void",
+      "signature": "(const ImVec2,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowSizeConstraints": [
+    {
+      "args": "(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data)",
+      "argsT": [
+        {
+          "name": "size_min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "size_max",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "custom_callback",
+          "type": "ImGuiSizeCallback"
+        },
+        {
+          "name": "custom_callback_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size_min,const ImVec2& size_max,ImGuiSizeCallback custom_callback=((void*)0),void* custom_callback_data=((void*)0))",
+      "call_args": "(size_min,size_max,custom_callback,custom_callback_data)",
+      "cimguiname": "igSetNextWindowSizeConstraints",
+      "defaults": {
+        "custom_callback": "NULL",
+        "custom_callback_data": "NULL"
+      },
+      "funcname": "SetNextWindowSizeConstraints",
+      "location": "imgui:417",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowSizeConstraints",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImGuiSizeCallback,void*)",
+      "stname": ""
+    }
+  ],
+  "igSetNextWindowViewport": [
+    {
+      "args": "(ImGuiID viewport_id)",
+      "argsT": [
+        {
+          "name": "viewport_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID viewport_id)",
+      "call_args": "(viewport_id)",
+      "cimguiname": "igSetNextWindowViewport",
+      "defaults": {},
+      "funcname": "SetNextWindowViewport",
+      "location": "imgui:423",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetNextWindowViewport",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igSetScrollFromPosX": [
+    {
+      "args": "(float local_x,float center_x_ratio)",
+      "argsT": [
+        {
+          "name": "local_x",
+          "type": "float"
+        },
+        {
+          "name": "center_x_ratio",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float local_x,float center_x_ratio=0.5f)",
+      "call_args": "(local_x,center_x_ratio)",
+      "cimguiname": "igSetScrollFromPosX",
+      "defaults": {
+        "center_x_ratio": "0.5f"
+      },
+      "funcname": "SetScrollFromPosX",
+      "location": "imgui:445",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollFromPosX_Float",
+      "ret": "void",
+      "signature": "(float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,float local_x,float center_x_ratio)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "local_x",
+          "type": "float"
+        },
+        {
+          "name": "center_x_ratio",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,float local_x,float center_x_ratio)",
+      "call_args": "(window,local_x,center_x_ratio)",
+      "cimguiname": "igSetScrollFromPosX",
+      "defaults": {},
+      "funcname": "SetScrollFromPosX",
+      "location": "imgui_internal:3286",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollFromPosX_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,float,float)",
+      "stname": ""
+    }
+  ],
+  "igSetScrollFromPosY": [
+    {
+      "args": "(float local_y,float center_y_ratio)",
+      "argsT": [
+        {
+          "name": "local_y",
+          "type": "float"
+        },
+        {
+          "name": "center_y_ratio",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float local_y,float center_y_ratio=0.5f)",
+      "call_args": "(local_y,center_y_ratio)",
+      "cimguiname": "igSetScrollFromPosY",
+      "defaults": {
+        "center_y_ratio": "0.5f"
+      },
+      "funcname": "SetScrollFromPosY",
+      "location": "imgui:446",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollFromPosY_Float",
+      "ret": "void",
+      "signature": "(float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,float local_y,float center_y_ratio)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "local_y",
+          "type": "float"
+        },
+        {
+          "name": "center_y_ratio",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,float local_y,float center_y_ratio)",
+      "call_args": "(window,local_y,center_y_ratio)",
+      "cimguiname": "igSetScrollFromPosY",
+      "defaults": {},
+      "funcname": "SetScrollFromPosY",
+      "location": "imgui_internal:3287",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollFromPosY_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,float,float)",
+      "stname": ""
+    }
+  ],
+  "igSetScrollHereX": [
+    {
+      "args": "(float center_x_ratio)",
+      "argsT": [
+        {
+          "name": "center_x_ratio",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float center_x_ratio=0.5f)",
+      "call_args": "(center_x_ratio)",
+      "cimguiname": "igSetScrollHereX",
+      "defaults": {
+        "center_x_ratio": "0.5f"
+      },
+      "funcname": "SetScrollHereX",
+      "location": "imgui:443",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollHereX",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetScrollHereY": [
+    {
+      "args": "(float center_y_ratio)",
+      "argsT": [
+        {
+          "name": "center_y_ratio",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float center_y_ratio=0.5f)",
+      "call_args": "(center_y_ratio)",
+      "cimguiname": "igSetScrollHereY",
+      "defaults": {
+        "center_y_ratio": "0.5f"
+      },
+      "funcname": "SetScrollHereY",
+      "location": "imgui:444",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollHereY",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetScrollX": [
+    {
+      "args": "(float scroll_x)",
+      "argsT": [
+        {
+          "name": "scroll_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float scroll_x)",
+      "call_args": "(scroll_x)",
+      "cimguiname": "igSetScrollX",
+      "defaults": {},
+      "funcname": "SetScrollX",
+      "location": "imgui:439",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollX_Float",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,float scroll_x)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "scroll_x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,float scroll_x)",
+      "call_args": "(window,scroll_x)",
+      "cimguiname": "igSetScrollX",
+      "defaults": {},
+      "funcname": "SetScrollX",
+      "location": "imgui_internal:3284",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollX_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,float)",
+      "stname": ""
+    }
+  ],
+  "igSetScrollY": [
+    {
+      "args": "(float scroll_y)",
+      "argsT": [
+        {
+          "name": "scroll_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float scroll_y)",
+      "call_args": "(scroll_y)",
+      "cimguiname": "igSetScrollY",
+      "defaults": {},
+      "funcname": "SetScrollY",
+      "location": "imgui:440",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollY_Float",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,float scroll_y)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "scroll_y",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,float scroll_y)",
+      "call_args": "(window,scroll_y)",
+      "cimguiname": "igSetScrollY",
+      "defaults": {},
+      "funcname": "SetScrollY",
+      "location": "imgui_internal:3285",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetScrollY_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,float)",
+      "stname": ""
+    }
+  ],
+  "igSetShortcutRouting": [
+    {
+      "args": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "call_args": "(key_chord,flags,owner_id)",
+      "cimguiname": "igSetShortcutRouting",
+      "defaults": {},
+      "funcname": "SetShortcutRouting",
+      "location": "imgui_internal:3474",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetShortcutRouting",
+      "ret": "bool",
+      "signature": "(ImGuiKeyChord,ImGuiInputFlags,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igSetStateStorage": [
+    {
+      "args": "(ImGuiStorage* storage)",
+      "argsT": [
+        {
+          "name": "storage",
+          "type": "ImGuiStorage*"
+        }
+      ],
+      "argsoriginal": "(ImGuiStorage* storage)",
+      "call_args": "(storage)",
+      "cimguiname": "igSetStateStorage",
+      "defaults": {},
+      "funcname": "SetStateStorage",
+      "location": "imgui:980",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetStateStorage",
+      "ret": "void",
+      "signature": "(ImGuiStorage*)",
+      "stname": ""
+    }
+  ],
+  "igSetTabItemClosed": [
+    {
+      "args": "(const char* tab_or_docked_window_label)",
+      "argsT": [
+        {
+          "name": "tab_or_docked_window_label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* tab_or_docked_window_label)",
+      "call_args": "(tab_or_docked_window_label)",
+      "cimguiname": "igSetTabItemClosed",
+      "defaults": {},
+      "funcname": "SetTabItemClosed",
+      "location": "imgui:874",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetTabItemClosed",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igSetTooltip": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igSetTooltip",
+      "defaults": {},
+      "funcname": "SetTooltip",
+      "isvararg": "...)",
+      "location": "imgui:746",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetTooltip",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igSetTooltipV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igSetTooltipV",
+      "defaults": {},
+      "funcname": "SetTooltipV",
+      "location": "imgui:747",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetTooltipV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowClipRectBeforeSetChannel": [
+    {
+      "args": "(ImGuiWindow* window,const ImRect clip_rect)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "clip_rect",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImRect& clip_rect)",
+      "call_args": "(window,clip_rect)",
+      "cimguiname": "igSetWindowClipRectBeforeSetChannel",
+      "defaults": {},
+      "funcname": "SetWindowClipRectBeforeSetChannel",
+      "location": "imgui_internal:3573",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowClipRectBeforeSetChannel",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowCollapsed": [
+    {
+      "args": "(bool collapsed,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "collapsed",
+          "type": "bool"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(bool collapsed,ImGuiCond cond=0)",
+      "call_args": "(collapsed,cond)",
+      "cimguiname": "igSetWindowCollapsed",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowCollapsed",
+      "location": "imgui:426",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowCollapsed_Bool",
+      "ret": "void",
+      "signature": "(bool,ImGuiCond)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* name,bool collapsed,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "collapsed",
+          "type": "bool"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const char* name,bool collapsed,ImGuiCond cond=0)",
+      "call_args": "(name,collapsed,cond)",
+      "cimguiname": "igSetWindowCollapsed",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowCollapsed",
+      "location": "imgui:431",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowCollapsed_Str",
+      "ret": "void",
+      "signature": "(const char*,bool,ImGuiCond)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,bool collapsed,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "collapsed",
+          "type": "bool"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,bool collapsed,ImGuiCond cond=0)",
+      "call_args": "(window,collapsed,cond)",
+      "cimguiname": "igSetWindowCollapsed",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowCollapsed",
+      "location": "imgui_internal:3210",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowCollapsed_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,bool,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowDock": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiID dock_id,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "dock_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiID dock_id,ImGuiCond cond)",
+      "call_args": "(window,dock_id,cond)",
+      "cimguiname": "igSetWindowDock",
+      "defaults": {},
+      "funcname": "SetWindowDock",
+      "location": "imgui_internal:3507",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowDock",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiID,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowFocus": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSetWindowFocus",
+      "defaults": {},
+      "funcname": "SetWindowFocus",
+      "location": "imgui:427",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowFocus_Nil",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    },
+    {
+      "args": "(const char* name)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "igSetWindowFocus",
+      "defaults": {},
+      "funcname": "SetWindowFocus",
+      "location": "imgui:432",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowFocus_Str",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowFontScale": [
+    {
+      "args": "(float scale)",
+      "argsT": [
+        {
+          "name": "scale",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float scale)",
+      "call_args": "(scale)",
+      "cimguiname": "igSetWindowFontScale",
+      "defaults": {},
+      "funcname": "SetWindowFontScale",
+      "location": "imgui:428",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowFontScale",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowHiddenAndSkipItemsForCurrentFrame": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igSetWindowHiddenAndSkipItemsForCurrentFrame",
+      "defaults": {},
+      "funcname": "SetWindowHiddenAndSkipItemsForCurrentFrame",
+      "location": "imgui_internal:3212",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowHiddenAndSkipItemsForCurrentFrame",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowHitTestHole": [
+    {
+      "args": "(ImGuiWindow* window,const ImVec2 pos,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImVec2& pos,const ImVec2& size)",
+      "call_args": "(window,pos,size)",
+      "cimguiname": "igSetWindowHitTestHole",
+      "defaults": {},
+      "funcname": "SetWindowHitTestHole",
+      "location": "imgui_internal:3211",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowHitTestHole",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowParentWindowForFocusRoute": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiWindow* parent_window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "parent_window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiWindow* parent_window)",
+      "call_args": "(window,parent_window)",
+      "cimguiname": "igSetWindowParentWindowForFocusRoute",
+      "defaults": {},
+      "funcname": "SetWindowParentWindowForFocusRoute",
+      "location": "imgui_internal:3213",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowParentWindowForFocusRoute",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowPos": [
+    {
+      "args": "(const ImVec2 pos,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,ImGuiCond cond=0)",
+      "call_args": "(pos,cond)",
+      "cimguiname": "igSetWindowPos",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowPos",
+      "location": "imgui:424",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowPos_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2,ImGuiCond)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* name,const ImVec2 pos,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const char* name,const ImVec2& pos,ImGuiCond cond=0)",
+      "call_args": "(name,pos,cond)",
+      "cimguiname": "igSetWindowPos",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowPos",
+      "location": "imgui:429",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowPos_Str",
+      "ret": "void",
+      "signature": "(const char*,const ImVec2,ImGuiCond)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,const ImVec2 pos,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImVec2& pos,ImGuiCond cond=0)",
+      "call_args": "(window,pos,cond)",
+      "cimguiname": "igSetWindowPos",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowPos",
+      "location": "imgui_internal:3208",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowPos_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImVec2,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowSize": [
+    {
+      "args": "(const ImVec2 size,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size,ImGuiCond cond=0)",
+      "call_args": "(size,cond)",
+      "cimguiname": "igSetWindowSize",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowSize",
+      "location": "imgui:425",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowSize_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2,ImGuiCond)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* name,const ImVec2 size,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(const char* name,const ImVec2& size,ImGuiCond cond=0)",
+      "call_args": "(name,size,cond)",
+      "cimguiname": "igSetWindowSize",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowSize",
+      "location": "imgui:430",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowSize_Str",
+      "ret": "void",
+      "signature": "(const char*,const ImVec2,ImGuiCond)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiWindow* window,const ImVec2 size,ImGuiCond cond)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cond",
+          "type": "ImGuiCond"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImVec2& size,ImGuiCond cond=0)",
+      "call_args": "(window,size,cond)",
+      "cimguiname": "igSetWindowSize",
+      "defaults": {
+        "cond": "0"
+      },
+      "funcname": "SetWindowSize",
+      "location": "imgui_internal:3209",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowSize_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImVec2,ImGuiCond)",
+      "stname": ""
+    }
+  ],
+  "igSetWindowViewport": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiViewportP* viewport)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiViewportP* viewport)",
+      "call_args": "(window,viewport)",
+      "cimguiname": "igSetWindowViewport",
+      "defaults": {},
+      "funcname": "SetWindowViewport",
+      "location": "imgui_internal:3260",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSetWindowViewport",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiViewportP*)",
+      "stname": ""
+    }
+  ],
+  "igShadeVertsLinearColorGradientKeepAlpha": [
+    {
+      "args": "(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,ImVec2 gradient_p0,ImVec2 gradient_p1,ImU32 col0,ImU32 col1)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "vert_start_idx",
+          "type": "int"
+        },
+        {
+          "name": "vert_end_idx",
+          "type": "int"
+        },
+        {
+          "name": "gradient_p0",
+          "type": "ImVec2"
+        },
+        {
+          "name": "gradient_p1",
+          "type": "ImVec2"
+        },
+        {
+          "name": "col0",
+          "type": "ImU32"
+        },
+        {
+          "name": "col1",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,ImVec2 gradient_p0,ImVec2 gradient_p1,ImU32 col0,ImU32 col1)",
+      "call_args": "(draw_list,vert_start_idx,vert_end_idx,gradient_p0,gradient_p1,col0,col1)",
+      "cimguiname": "igShadeVertsLinearColorGradientKeepAlpha",
+      "defaults": {},
+      "funcname": "ShadeVertsLinearColorGradientKeepAlpha",
+      "location": "imgui_internal:3761",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShadeVertsLinearColorGradientKeepAlpha",
+      "ret": "void",
+      "signature": "(ImDrawList*,int,int,ImVec2,ImVec2,ImU32,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igShadeVertsLinearUV": [
+    {
+      "args": "(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,bool clamp)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "vert_start_idx",
+          "type": "int"
+        },
+        {
+          "name": "vert_end_idx",
+          "type": "int"
+        },
+        {
+          "name": "a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_a",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv_b",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clamp",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2& a,const ImVec2& b,const ImVec2& uv_a,const ImVec2& uv_b,bool clamp)",
+      "call_args": "(draw_list,vert_start_idx,vert_end_idx,a,b,uv_a,uv_b,clamp)",
+      "cimguiname": "igShadeVertsLinearUV",
+      "defaults": {},
+      "funcname": "ShadeVertsLinearUV",
+      "location": "imgui_internal:3762",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShadeVertsLinearUV",
+      "ret": "void",
+      "signature": "(ImDrawList*,int,int,const ImVec2,const ImVec2,const ImVec2,const ImVec2,bool)",
+      "stname": ""
+    }
+  ],
+  "igShadeVertsTransformPos": [
+    {
+      "args": "(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2 pivot_in,float cos_a,float sin_a,const ImVec2 pivot_out)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "vert_start_idx",
+          "type": "int"
+        },
+        {
+          "name": "vert_end_idx",
+          "type": "int"
+        },
+        {
+          "name": "pivot_in",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cos_a",
+          "type": "float"
+        },
+        {
+          "name": "sin_a",
+          "type": "float"
+        },
+        {
+          "name": "pivot_out",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,int vert_start_idx,int vert_end_idx,const ImVec2& pivot_in,float cos_a,float sin_a,const ImVec2& pivot_out)",
+      "call_args": "(draw_list,vert_start_idx,vert_end_idx,pivot_in,cos_a,sin_a,pivot_out)",
+      "cimguiname": "igShadeVertsTransformPos",
+      "defaults": {},
+      "funcname": "ShadeVertsTransformPos",
+      "location": "imgui_internal:3763",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShadeVertsTransformPos",
+      "ret": "void",
+      "signature": "(ImDrawList*,int,int,const ImVec2,float,float,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igShortcut": [
+    {
+      "args": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags=0)",
+      "call_args": "(key_chord,flags)",
+      "cimguiname": "igShortcut",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "Shortcut",
+      "location": "imgui:1019",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShortcut_Nil",
+      "ret": "bool",
+      "signature": "(ImGuiKeyChord,ImGuiInputFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputFlags"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord,ImGuiInputFlags flags,ImGuiID owner_id)",
+      "call_args": "(key_chord,flags,owner_id)",
+      "cimguiname": "igShortcut",
+      "defaults": {},
+      "funcname": "Shortcut",
+      "location": "imgui_internal:3473",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShortcut_ID",
+      "ret": "bool",
+      "signature": "(ImGuiKeyChord,ImGuiInputFlags,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igShowAboutWindow": [
+    {
+      "args": "(bool* p_open)",
+      "argsT": [
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_open=((void*)0))",
+      "call_args": "(p_open)",
+      "cimguiname": "igShowAboutWindow",
+      "defaults": {
+        "p_open": "NULL"
+      },
+      "funcname": "ShowAboutWindow",
+      "location": "imgui:350",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowAboutWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "igShowDebugLogWindow": [
+    {
+      "args": "(bool* p_open)",
+      "argsT": [
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_open=((void*)0))",
+      "call_args": "(p_open)",
+      "cimguiname": "igShowDebugLogWindow",
+      "defaults": {
+        "p_open": "NULL"
+      },
+      "funcname": "ShowDebugLogWindow",
+      "location": "imgui:348",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowDebugLogWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "igShowDemoWindow": [
+    {
+      "args": "(bool* p_open)",
+      "argsT": [
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_open=((void*)0))",
+      "call_args": "(p_open)",
+      "cimguiname": "igShowDemoWindow",
+      "defaults": {
+        "p_open": "NULL"
+      },
+      "funcname": "ShowDemoWindow",
+      "location": "imgui:346",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowDemoWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "igShowFontAtlas": [
+    {
+      "args": "(ImFontAtlas* atlas)",
+      "argsT": [
+        {
+          "name": "atlas",
+          "type": "ImFontAtlas*"
+        }
+      ],
+      "argsoriginal": "(ImFontAtlas* atlas)",
+      "call_args": "(atlas)",
+      "cimguiname": "igShowFontAtlas",
+      "defaults": {},
+      "funcname": "ShowFontAtlas",
+      "location": "imgui_internal:3792",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowFontAtlas",
+      "ret": "void",
+      "signature": "(ImFontAtlas*)",
+      "stname": ""
+    }
+  ],
+  "igShowFontSelector": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igShowFontSelector",
+      "defaults": {},
+      "funcname": "ShowFontSelector",
+      "location": "imgui:353",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowFontSelector",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igShowIDStackToolWindow": [
+    {
+      "args": "(bool* p_open)",
+      "argsT": [
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_open=((void*)0))",
+      "call_args": "(p_open)",
+      "cimguiname": "igShowIDStackToolWindow",
+      "defaults": {
+        "p_open": "NULL"
+      },
+      "funcname": "ShowIDStackToolWindow",
+      "location": "imgui:349",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowIDStackToolWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "igShowMetricsWindow": [
+    {
+      "args": "(bool* p_open)",
+      "argsT": [
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_open=((void*)0))",
+      "call_args": "(p_open)",
+      "cimguiname": "igShowMetricsWindow",
+      "defaults": {
+        "p_open": "NULL"
+      },
+      "funcname": "ShowMetricsWindow",
+      "location": "imgui:347",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowMetricsWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "igShowStyleEditor": [
+    {
+      "args": "(ImGuiStyle* ref)",
+      "argsT": [
+        {
+          "name": "ref",
+          "type": "ImGuiStyle*"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyle* ref=((void*)0))",
+      "call_args": "(ref)",
+      "cimguiname": "igShowStyleEditor",
+      "defaults": {
+        "ref": "NULL"
+      },
+      "funcname": "ShowStyleEditor",
+      "location": "imgui:351",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowStyleEditor",
+      "ret": "void",
+      "signature": "(ImGuiStyle*)",
+      "stname": ""
+    }
+  ],
+  "igShowStyleSelector": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igShowStyleSelector",
+      "defaults": {},
+      "funcname": "ShowStyleSelector",
+      "location": "imgui:352",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowStyleSelector",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igShowUserGuide": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igShowUserGuide",
+      "defaults": {},
+      "funcname": "ShowUserGuide",
+      "location": "imgui:354",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShowUserGuide",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igShrinkWidths": [
+    {
+      "args": "(ImGuiShrinkWidthItem* items,int count,float width_excess)",
+      "argsT": [
+        {
+          "name": "items",
+          "type": "ImGuiShrinkWidthItem*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "width_excess",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiShrinkWidthItem* items,int count,float width_excess)",
+      "call_args": "(items,count,width_excess)",
+      "cimguiname": "igShrinkWidths",
+      "defaults": {},
+      "funcname": "ShrinkWidths",
+      "location": "imgui_internal:3324",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShrinkWidths",
+      "ret": "void",
+      "signature": "(ImGuiShrinkWidthItem*,int,float)",
+      "stname": ""
+    }
+  ],
+  "igShutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igShutdown",
+      "defaults": {},
+      "funcname": "Shutdown",
+      "location": "imgui_internal:3240",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igShutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSliderAngle": [
+    {
+      "args": "(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v_rad",
+          "type": "float*"
+        },
+        {
+          "name": "v_degrees_min",
+          "type": "float"
+        },
+        {
+          "name": "v_degrees_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float* v_rad,float v_degrees_min=-360.0f,float v_degrees_max=+360.0f,const char* format=\"%.0f deg\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v_rad,v_degrees_min,v_degrees_max,format,flags)",
+      "cimguiname": "igSliderAngle",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.0f deg\"",
+        "v_degrees_max": "+360.0f",
+        "v_degrees_min": "-360.0f"
+      },
+      "funcname": "SliderAngle",
+      "location": "imgui:623",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderAngle",
+      "ret": "bool",
+      "signature": "(const char*,float*,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderBehavior": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,ImGuiDataType data_type,void* p_v,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags,ImRect* out_grab_bb)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_v",
+          "type": "void*"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        },
+        {
+          "name": "out_grab_bb",
+          "type": "ImRect*"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,ImGuiDataType data_type,void* p_v,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags,ImRect* out_grab_bb)",
+      "call_args": "(bb,id,data_type,p_v,p_min,p_max,format,flags,out_grab_bb)",
+      "cimguiname": "igSliderBehavior",
+      "defaults": {},
+      "funcname": "SliderBehavior",
+      "location": "imgui_internal:3714",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderBehavior",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,ImGuiDataType,void*,const void*,const void*,const char*,ImGuiSliderFlags,ImRect*)",
+      "stname": ""
+    }
+  ],
+  "igSliderFloat": [
+    {
+      "args": "(const char* label,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float*"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float* v,float v_min,float v_max,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderFloat",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "SliderFloat",
+      "location": "imgui:619",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderFloat",
+      "ret": "bool",
+      "signature": "(const char*,float*,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderFloat2": [
+    {
+      "args": "(const char* label,float v[2],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[2]"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[2],float v_min,float v_max,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderFloat2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "SliderFloat2",
+      "location": "imgui:620",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderFloat2",
+      "ret": "bool",
+      "signature": "(const char*,float[2],float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderFloat3": [
+    {
+      "args": "(const char* label,float v[3],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[3]"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[3],float v_min,float v_max,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderFloat3",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "SliderFloat3",
+      "location": "imgui:621",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderFloat3",
+      "ret": "bool",
+      "signature": "(const char*,float[3],float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderFloat4": [
+    {
+      "args": "(const char* label,float v[4],float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float[4]"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,float v[4],float v_min,float v_max,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderFloat4",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "SliderFloat4",
+      "location": "imgui:622",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderFloat4",
+      "ret": "bool",
+      "signature": "(const char*,float[4],float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderInt": [
+    {
+      "args": "(const char* label,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int*"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int* v,int v_min,int v_max,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderInt",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\""
+      },
+      "funcname": "SliderInt",
+      "location": "imgui:624",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderInt",
+      "ret": "bool",
+      "signature": "(const char*,int*,int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderInt2": [
+    {
+      "args": "(const char* label,int v[2],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[2]"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[2],int v_min,int v_max,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderInt2",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\""
+      },
+      "funcname": "SliderInt2",
+      "location": "imgui:625",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderInt2",
+      "ret": "bool",
+      "signature": "(const char*,int[2],int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderInt3": [
+    {
+      "args": "(const char* label,int v[3],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[3]"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[3],int v_min,int v_max,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderInt3",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\""
+      },
+      "funcname": "SliderInt3",
+      "location": "imgui:626",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderInt3",
+      "ret": "bool",
+      "signature": "(const char*,int[3],int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderInt4": [
+    {
+      "args": "(const char* label,int v[4],int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int[4]"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,int v[4],int v_min,int v_max,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,v,v_min,v_max,format,flags)",
+      "cimguiname": "igSliderInt4",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\""
+      },
+      "funcname": "SliderInt4",
+      "location": "imgui:627",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderInt4",
+      "ret": "bool",
+      "signature": "(const char*,int[4],int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderScalar": [
+    {
+      "args": "(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,data_type,p_data,p_min,p_max,format,flags)",
+      "cimguiname": "igSliderScalar",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL"
+      },
+      "funcname": "SliderScalar",
+      "location": "imgui:628",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderScalar",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,const void*,const void*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSliderScalarN": [
+    {
+      "args": "(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "components",
+          "type": "int"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiDataType data_type,void* p_data,int components,const void* p_min,const void* p_max,const char* format=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,data_type,p_data,components,p_min,p_max,format,flags)",
+      "cimguiname": "igSliderScalarN",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL"
+      },
+      "funcname": "SliderScalarN",
+      "location": "imgui:629",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSliderScalarN",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDataType,void*,int,const void*,const void*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igSmallButton": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igSmallButton",
+      "defaults": {},
+      "funcname": "SmallButton",
+      "location": "imgui:558",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSmallButton",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igSpacing": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igSpacing",
+      "defaults": {},
+      "funcname": "Spacing",
+      "location": "imgui:505",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSpacing",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igSplitterBehavior": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,ImGuiAxis axis,float* size1,float* size2,float min_size1,float min_size2,float hover_extend,float hover_visibility_delay,ImU32 bg_col)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "axis",
+          "type": "ImGuiAxis"
+        },
+        {
+          "name": "size1",
+          "type": "float*"
+        },
+        {
+          "name": "size2",
+          "type": "float*"
+        },
+        {
+          "name": "min_size1",
+          "type": "float"
+        },
+        {
+          "name": "min_size2",
+          "type": "float"
+        },
+        {
+          "name": "hover_extend",
+          "type": "float"
+        },
+        {
+          "name": "hover_visibility_delay",
+          "type": "float"
+        },
+        {
+          "name": "bg_col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,ImGuiAxis axis,float* size1,float* size2,float min_size1,float min_size2,float hover_extend=0.0f,float hover_visibility_delay=0.0f,ImU32 bg_col=0)",
+      "call_args": "(bb,id,axis,size1,size2,min_size1,min_size2,hover_extend,hover_visibility_delay,bg_col)",
+      "cimguiname": "igSplitterBehavior",
+      "defaults": {
+        "bg_col": "0",
+        "hover_extend": "0.0f",
+        "hover_visibility_delay": "0.0f"
+      },
+      "funcname": "SplitterBehavior",
+      "location": "imgui_internal:3715",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igSplitterBehavior",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,ImGuiAxis,float*,float*,float,float,float,float,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igStartMouseMovingWindow": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igStartMouseMovingWindow",
+      "defaults": {},
+      "funcname": "StartMouseMovingWindow",
+      "location": "imgui_internal:3246",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igStartMouseMovingWindow",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igStartMouseMovingWindowOrNode": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiDockNode* node,bool undock)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "node",
+          "type": "ImGuiDockNode*"
+        },
+        {
+          "name": "undock",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiDockNode* node,bool undock)",
+      "call_args": "(window,node,undock)",
+      "cimguiname": "igStartMouseMovingWindowOrNode",
+      "defaults": {},
+      "funcname": "StartMouseMovingWindowOrNode",
+      "location": "imgui_internal:3247",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igStartMouseMovingWindowOrNode",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiDockNode*,bool)",
+      "stname": ""
+    }
+  ],
+  "igStyleColorsClassic": [
+    {
+      "args": "(ImGuiStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImGuiStyle*"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "igStyleColorsClassic",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsClassic",
+      "location": "imgui:360",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igStyleColorsClassic",
+      "ret": "void",
+      "signature": "(ImGuiStyle*)",
+      "stname": ""
+    }
+  ],
+  "igStyleColorsDark": [
+    {
+      "args": "(ImGuiStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImGuiStyle*"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "igStyleColorsDark",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsDark",
+      "location": "imgui:358",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igStyleColorsDark",
+      "ret": "void",
+      "signature": "(ImGuiStyle*)",
+      "stname": ""
+    }
+  ],
+  "igStyleColorsLight": [
+    {
+      "args": "(ImGuiStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImGuiStyle*"
+        }
+      ],
+      "argsoriginal": "(ImGuiStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "igStyleColorsLight",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsLight",
+      "location": "imgui:359",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igStyleColorsLight",
+      "ret": "void",
+      "signature": "(ImGuiStyle*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarAddTab": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItemFlags tab_flags,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab_flags",
+          "type": "ImGuiTabItemFlags"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItemFlags tab_flags,ImGuiWindow* window)",
+      "call_args": "(tab_bar,tab_flags,window)",
+      "cimguiname": "igTabBarAddTab",
+      "defaults": {},
+      "funcname": "TabBarAddTab",
+      "location": "imgui_internal:3649",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarAddTab",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,ImGuiTabItemFlags,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarCloseTab": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab",
+          "type": "ImGuiTabItem*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "call_args": "(tab_bar,tab)",
+      "cimguiname": "igTabBarCloseTab",
+      "defaults": {},
+      "funcname": "TabBarCloseTab",
+      "location": "imgui_internal:3651",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarCloseTab",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,ImGuiTabItem*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarFindMostRecentlySelectedTabForActiveWindow": [
+    {
+      "args": "(ImGuiTabBar* tab_bar)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar)",
+      "call_args": "(tab_bar)",
+      "cimguiname": "igTabBarFindMostRecentlySelectedTabForActiveWindow",
+      "defaults": {},
+      "funcname": "TabBarFindMostRecentlySelectedTabForActiveWindow",
+      "location": "imgui_internal:3645",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarFindMostRecentlySelectedTabForActiveWindow",
+      "ret": "ImGuiTabItem*",
+      "signature": "(ImGuiTabBar*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarFindTabByID": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiID tab_id)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiID tab_id)",
+      "call_args": "(tab_bar,tab_id)",
+      "cimguiname": "igTabBarFindTabByID",
+      "defaults": {},
+      "funcname": "TabBarFindTabByID",
+      "location": "imgui_internal:3643",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarFindTabByID",
+      "ret": "ImGuiTabItem*",
+      "signature": "(ImGuiTabBar*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTabBarFindTabByOrder": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,int order)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "order",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,int order)",
+      "call_args": "(tab_bar,order)",
+      "cimguiname": "igTabBarFindTabByOrder",
+      "defaults": {},
+      "funcname": "TabBarFindTabByOrder",
+      "location": "imgui_internal:3644",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarFindTabByOrder",
+      "ret": "ImGuiTabItem*",
+      "signature": "(ImGuiTabBar*,int)",
+      "stname": ""
+    }
+  ],
+  "igTabBarGetCurrentTab": [
+    {
+      "args": "(ImGuiTabBar* tab_bar)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar)",
+      "call_args": "(tab_bar)",
+      "cimguiname": "igTabBarGetCurrentTab",
+      "defaults": {},
+      "funcname": "TabBarGetCurrentTab",
+      "location": "imgui_internal:3646",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarGetCurrentTab",
+      "ret": "ImGuiTabItem*",
+      "signature": "(ImGuiTabBar*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarGetTabName": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab",
+          "type": "ImGuiTabItem*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "call_args": "(tab_bar,tab)",
+      "cimguiname": "igTabBarGetTabName",
+      "defaults": {},
+      "funcname": "TabBarGetTabName",
+      "location": "imgui_internal:3648",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarGetTabName",
+      "ret": "const char*",
+      "signature": "(ImGuiTabBar*,ImGuiTabItem*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarGetTabOrder": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab",
+          "type": "ImGuiTabItem*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "call_args": "(tab_bar,tab)",
+      "cimguiname": "igTabBarGetTabOrder",
+      "defaults": {},
+      "funcname": "TabBarGetTabOrder",
+      "location": "imgui_internal:3647",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarGetTabOrder",
+      "ret": "int",
+      "signature": "(ImGuiTabBar*,ImGuiTabItem*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarProcessReorder": [
+    {
+      "args": "(ImGuiTabBar* tab_bar)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar)",
+      "call_args": "(tab_bar)",
+      "cimguiname": "igTabBarProcessReorder",
+      "defaults": {},
+      "funcname": "TabBarProcessReorder",
+      "location": "imgui_internal:3656",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarProcessReorder",
+      "ret": "bool",
+      "signature": "(ImGuiTabBar*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarQueueFocus": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab",
+          "type": "ImGuiTabItem*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab)",
+      "call_args": "(tab_bar,tab)",
+      "cimguiname": "igTabBarQueueFocus",
+      "defaults": {},
+      "funcname": "TabBarQueueFocus",
+      "location": "imgui_internal:3652",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarQueueFocus_TabItemPtr",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,ImGuiTabItem*)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiTabBar* tab_bar,const char* tab_name)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,const char* tab_name)",
+      "call_args": "(tab_bar,tab_name)",
+      "cimguiname": "igTabBarQueueFocus",
+      "defaults": {},
+      "funcname": "TabBarQueueFocus",
+      "location": "imgui_internal:3653",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarQueueFocus_Str",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igTabBarQueueReorder": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,int offset)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab",
+          "type": "ImGuiTabItem*"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,int offset)",
+      "call_args": "(tab_bar,tab,offset)",
+      "cimguiname": "igTabBarQueueReorder",
+      "defaults": {},
+      "funcname": "TabBarQueueReorder",
+      "location": "imgui_internal:3654",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarQueueReorder",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,ImGuiTabItem*,int)",
+      "stname": ""
+    }
+  ],
+  "igTabBarQueueReorderFromMousePos": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,ImVec2 mouse_pos)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab",
+          "type": "ImGuiTabItem*"
+        },
+        {
+          "name": "mouse_pos",
+          "type": "ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiTabItem* tab,ImVec2 mouse_pos)",
+      "call_args": "(tab_bar,tab,mouse_pos)",
+      "cimguiname": "igTabBarQueueReorderFromMousePos",
+      "defaults": {},
+      "funcname": "TabBarQueueReorderFromMousePos",
+      "location": "imgui_internal:3655",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarQueueReorderFromMousePos",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,ImGuiTabItem*,ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igTabBarRemoveTab": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,ImGuiID tab_id)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "tab_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,ImGuiID tab_id)",
+      "call_args": "(tab_bar,tab_id)",
+      "cimguiname": "igTabBarRemoveTab",
+      "defaults": {},
+      "funcname": "TabBarRemoveTab",
+      "location": "imgui_internal:3650",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabBarRemoveTab",
+      "ret": "void",
+      "signature": "(ImGuiTabBar*,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTabItemBackground": [
+    {
+      "args": "(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabItemFlags"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,const ImRect& bb,ImGuiTabItemFlags flags,ImU32 col)",
+      "call_args": "(draw_list,bb,flags,col)",
+      "cimguiname": "igTabItemBackground",
+      "defaults": {},
+      "funcname": "TabItemBackground",
+      "location": "imgui_internal:3660",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabItemBackground",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImRect,ImGuiTabItemFlags,ImU32)",
+      "stname": ""
+    }
+  ],
+  "igTabItemButton": [
+    {
+      "args": "(const char* label,ImGuiTabItemFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabItemFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiTabItemFlags flags=0)",
+      "call_args": "(label,flags)",
+      "cimguiname": "igTabItemButton",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "TabItemButton",
+      "location": "imgui:873",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabItemButton",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiTabItemFlags)",
+      "stname": ""
+    }
+  ],
+  "igTabItemCalcSize": [
+    {
+      "args": "(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "has_close_button_or_unsaved_marker",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* label,bool has_close_button_or_unsaved_marker)",
+      "call_args": "(label,has_close_button_or_unsaved_marker)",
+      "cimguiname": "igTabItemCalcSize",
+      "defaults": {},
+      "funcname": "TabItemCalcSize",
+      "location": "imgui_internal:3658",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igTabItemCalcSize_Str",
+      "ret": "void",
+      "signature": "(const char*,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVec2 *pOut,ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igTabItemCalcSize",
+      "defaults": {},
+      "funcname": "TabItemCalcSize",
+      "location": "imgui_internal:3659",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igTabItemCalcSize_WindowPtr",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igTabItemEx": [
+    {
+      "args": "(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags,ImGuiWindow* docked_window)",
+      "argsT": [
+        {
+          "name": "tab_bar",
+          "type": "ImGuiTabBar*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "p_open",
+          "type": "bool*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabItemFlags"
+        },
+        {
+          "name": "docked_window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags,ImGuiWindow* docked_window)",
+      "call_args": "(tab_bar,label,p_open,flags,docked_window)",
+      "cimguiname": "igTabItemEx",
+      "defaults": {},
+      "funcname": "TabItemEx",
+      "location": "imgui_internal:3657",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabItemEx",
+      "ret": "bool",
+      "signature": "(ImGuiTabBar*,const char*,bool*,ImGuiTabItemFlags,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igTabItemLabelAndCloseButton": [
+    {
+      "args": "(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id,bool is_contents_visible,bool* out_just_closed,bool* out_text_clipped)",
+      "argsT": [
+        {
+          "name": "draw_list",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTabItemFlags"
+        },
+        {
+          "name": "frame_padding",
+          "type": "ImVec2"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "tab_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "close_button_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "is_contents_visible",
+          "type": "bool"
+        },
+        {
+          "name": "out_just_closed",
+          "type": "bool*"
+        },
+        {
+          "name": "out_text_clipped",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* draw_list,const ImRect& bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id,bool is_contents_visible,bool* out_just_closed,bool* out_text_clipped)",
+      "call_args": "(draw_list,bb,flags,frame_padding,label,tab_id,close_button_id,is_contents_visible,out_just_closed,out_text_clipped)",
+      "cimguiname": "igTabItemLabelAndCloseButton",
+      "defaults": {},
+      "funcname": "TabItemLabelAndCloseButton",
+      "location": "imgui_internal:3661",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTabItemLabelAndCloseButton",
+      "ret": "void",
+      "signature": "(ImDrawList*,const ImRect,ImGuiTabItemFlags,ImVec2,const char*,ImGuiID,ImGuiID,bool,bool*,bool*)",
+      "stname": ""
+    }
+  ],
+  "igTableAngledHeadersRow": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableAngledHeadersRow",
+      "defaults": {},
+      "funcname": "TableAngledHeadersRow",
+      "location": "imgui:838",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableAngledHeadersRow",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableAngledHeadersRowEx": [
+    {
+      "args": "(ImGuiID row_id,float angle,float max_label_width,const ImGuiTableHeaderData* data,int data_count)",
+      "argsT": [
+        {
+          "name": "row_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "angle",
+          "type": "float"
+        },
+        {
+          "name": "max_label_width",
+          "type": "float"
+        },
+        {
+          "name": "data",
+          "type": "const ImGuiTableHeaderData*"
+        },
+        {
+          "name": "data_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiID row_id,float angle,float max_label_width,const ImGuiTableHeaderData* data,int data_count)",
+      "call_args": "(row_id,angle,max_label_width,data,data_count)",
+      "cimguiname": "igTableAngledHeadersRowEx",
+      "defaults": {},
+      "funcname": "TableAngledHeadersRowEx",
+      "location": "imgui_internal:3593",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableAngledHeadersRowEx",
+      "ret": "void",
+      "signature": "(ImGuiID,float,float,const ImGuiTableHeaderData*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableBeginApplyRequests": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableBeginApplyRequests",
+      "defaults": {},
+      "funcname": "TableBeginApplyRequests",
+      "location": "imgui_internal:3600",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableBeginApplyRequests",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableBeginCell": [
+    {
+      "args": "(ImGuiTable* table,int column_n)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,int column_n)",
+      "call_args": "(table,column_n)",
+      "cimguiname": "igTableBeginCell",
+      "defaults": {},
+      "funcname": "TableBeginCell",
+      "location": "imgui_internal:3618",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableBeginCell",
+      "ret": "void",
+      "signature": "(ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableBeginContextMenuPopup": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableBeginContextMenuPopup",
+      "defaults": {},
+      "funcname": "TableBeginContextMenuPopup",
+      "location": "imgui_internal:3607",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableBeginContextMenuPopup",
+      "ret": "bool",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableBeginInitMemory": [
+    {
+      "args": "(ImGuiTable* table,int columns_count)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "columns_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,int columns_count)",
+      "call_args": "(table,columns_count)",
+      "cimguiname": "igTableBeginInitMemory",
+      "defaults": {},
+      "funcname": "TableBeginInitMemory",
+      "location": "imgui_internal:3599",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableBeginInitMemory",
+      "ret": "void",
+      "signature": "(ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableBeginRow": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableBeginRow",
+      "defaults": {},
+      "funcname": "TableBeginRow",
+      "location": "imgui_internal:3616",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableBeginRow",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableCalcMaxColumnWidth": [
+    {
+      "args": "(const ImGuiTable* table,int column_n)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "const ImGuiTable*"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImGuiTable* table,int column_n)",
+      "call_args": "(table,column_n)",
+      "cimguiname": "igTableCalcMaxColumnWidth",
+      "defaults": {},
+      "funcname": "TableCalcMaxColumnWidth",
+      "location": "imgui_internal:3623",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableCalcMaxColumnWidth",
+      "ret": "float",
+      "signature": "(const ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableDrawBorders": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableDrawBorders",
+      "defaults": {},
+      "funcname": "TableDrawBorders",
+      "location": "imgui_internal:3605",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableDrawBorders",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableDrawDefaultContextMenu": [
+    {
+      "args": "(ImGuiTable* table,ImGuiTableFlags flags_for_section_to_display)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "flags_for_section_to_display",
+          "type": "ImGuiTableFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,ImGuiTableFlags flags_for_section_to_display)",
+      "call_args": "(table,flags_for_section_to_display)",
+      "cimguiname": "igTableDrawDefaultContextMenu",
+      "defaults": {},
+      "funcname": "TableDrawDefaultContextMenu",
+      "location": "imgui_internal:3606",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableDrawDefaultContextMenu",
+      "ret": "void",
+      "signature": "(ImGuiTable*,ImGuiTableFlags)",
+      "stname": ""
+    }
+  ],
+  "igTableEndCell": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableEndCell",
+      "defaults": {},
+      "funcname": "TableEndCell",
+      "location": "imgui_internal:3619",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableEndCell",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableEndRow": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableEndRow",
+      "defaults": {},
+      "funcname": "TableEndRow",
+      "location": "imgui_internal:3617",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableEndRow",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableFindByID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igTableFindByID",
+      "defaults": {},
+      "funcname": "TableFindByID",
+      "location": "imgui_internal:3597",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableFindByID",
+      "ret": "ImGuiTable*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTableFixColumnSortDirection": [
+    {
+      "args": "(ImGuiTable* table,ImGuiTableColumn* column)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "column",
+          "type": "ImGuiTableColumn*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,ImGuiTableColumn* column)",
+      "call_args": "(table,column)",
+      "cimguiname": "igTableFixColumnSortDirection",
+      "defaults": {},
+      "funcname": "TableFixColumnSortDirection",
+      "location": "imgui_internal:3614",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableFixColumnSortDirection",
+      "ret": "void",
+      "signature": "(ImGuiTable*,ImGuiTableColumn*)",
+      "stname": ""
+    }
+  ],
+  "igTableGcCompactSettings": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGcCompactSettings",
+      "defaults": {},
+      "funcname": "TableGcCompactSettings",
+      "location": "imgui_internal:3629",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGcCompactSettings",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGcCompactTransientBuffers": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableGcCompactTransientBuffers",
+      "defaults": {},
+      "funcname": "TableGcCompactTransientBuffers",
+      "location": "imgui_internal:3627",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGcCompactTransientBuffers_TablePtr",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    },
+    {
+      "args": "(ImGuiTableTempData* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTableTempData*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTableTempData* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableGcCompactTransientBuffers",
+      "defaults": {},
+      "funcname": "TableGcCompactTransientBuffers",
+      "location": "imgui_internal:3628",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGcCompactTransientBuffers_TableTempDataPtr",
+      "ret": "void",
+      "signature": "(ImGuiTableTempData*)",
+      "stname": ""
+    }
+  ],
+  "igTableGetBoundSettings": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableGetBoundSettings",
+      "defaults": {},
+      "funcname": "TableGetBoundSettings",
+      "location": "imgui_internal:3635",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetBoundSettings",
+      "ret": "ImGuiTableSettings*",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableGetCellBgRect": [
+    {
+      "args": "(ImRect *pOut,const ImGuiTable* table,int column_n)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "table",
+          "type": "const ImGuiTable*"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImGuiTable* table,int column_n)",
+      "call_args": "(table,column_n)",
+      "cimguiname": "igTableGetCellBgRect",
+      "defaults": {},
+      "funcname": "TableGetCellBgRect",
+      "location": "imgui_internal:3620",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igTableGetCellBgRect",
+      "ret": "void",
+      "signature": "(const ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnCount": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetColumnCount",
+      "defaults": {},
+      "funcname": "TableGetColumnCount",
+      "location": "imgui:847",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnCount",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnFlags": [
+    {
+      "args": "(int column_n)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_n=-1)",
+      "call_args": "(column_n)",
+      "cimguiname": "igTableGetColumnFlags",
+      "defaults": {
+        "column_n": "-1"
+      },
+      "funcname": "TableGetColumnFlags",
+      "location": "imgui:851",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnFlags",
+      "ret": "ImGuiTableColumnFlags",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnIndex": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetColumnIndex",
+      "defaults": {},
+      "funcname": "TableGetColumnIndex",
+      "location": "imgui:848",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnIndex",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnName": [
+    {
+      "args": "(int column_n)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_n=-1)",
+      "call_args": "(column_n)",
+      "cimguiname": "igTableGetColumnName",
+      "defaults": {
+        "column_n": "-1"
+      },
+      "funcname": "TableGetColumnName",
+      "location": "imgui:850",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnName_Int",
+      "ret": "const char*",
+      "signature": "(int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImGuiTable* table,int column_n)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "const ImGuiTable*"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImGuiTable* table,int column_n)",
+      "call_args": "(table,column_n)",
+      "cimguiname": "igTableGetColumnName",
+      "defaults": {},
+      "funcname": "TableGetColumnName",
+      "location": "imgui_internal:3621",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnName_TablePtr",
+      "ret": "const char*",
+      "signature": "(const ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnNextSortDirection": [
+    {
+      "args": "(ImGuiTableColumn* column)",
+      "argsT": [
+        {
+          "name": "column",
+          "type": "ImGuiTableColumn*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTableColumn* column)",
+      "call_args": "(column)",
+      "cimguiname": "igTableGetColumnNextSortDirection",
+      "defaults": {},
+      "funcname": "TableGetColumnNextSortDirection",
+      "location": "imgui_internal:3613",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnNextSortDirection",
+      "ret": "ImGuiSortDirection",
+      "signature": "(ImGuiTableColumn*)",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnResizeID": [
+    {
+      "args": "(ImGuiTable* table,int column_n,int instance_no)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        },
+        {
+          "name": "instance_no",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,int column_n,int instance_no=0)",
+      "call_args": "(table,column_n,instance_no)",
+      "cimguiname": "igTableGetColumnResizeID",
+      "defaults": {
+        "instance_no": "0"
+      },
+      "funcname": "TableGetColumnResizeID",
+      "location": "imgui_internal:3622",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnResizeID",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiTable*,int,int)",
+      "stname": ""
+    }
+  ],
+  "igTableGetColumnWidthAuto": [
+    {
+      "args": "(ImGuiTable* table,ImGuiTableColumn* column)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "column",
+          "type": "ImGuiTableColumn*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,ImGuiTableColumn* column)",
+      "call_args": "(table,column)",
+      "cimguiname": "igTableGetColumnWidthAuto",
+      "defaults": {},
+      "funcname": "TableGetColumnWidthAuto",
+      "location": "imgui_internal:3615",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetColumnWidthAuto",
+      "ret": "float",
+      "signature": "(ImGuiTable*,ImGuiTableColumn*)",
+      "stname": ""
+    }
+  ],
+  "igTableGetHeaderAngledMaxLabelWidth": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetHeaderAngledMaxLabelWidth",
+      "defaults": {},
+      "funcname": "TableGetHeaderAngledMaxLabelWidth",
+      "location": "imgui_internal:3590",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetHeaderAngledMaxLabelWidth",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetHeaderRowHeight": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetHeaderRowHeight",
+      "defaults": {},
+      "funcname": "TableGetHeaderRowHeight",
+      "location": "imgui_internal:3589",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetHeaderRowHeight",
+      "ret": "float",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetHoveredColumn": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetHoveredColumn",
+      "defaults": {},
+      "funcname": "TableGetHoveredColumn",
+      "location": "imgui:853",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetHoveredColumn",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetHoveredRow": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetHoveredRow",
+      "defaults": {},
+      "funcname": "TableGetHoveredRow",
+      "location": "imgui_internal:3588",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetHoveredRow",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetInstanceData": [
+    {
+      "args": "(ImGuiTable* table,int instance_no)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "instance_no",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,int instance_no)",
+      "call_args": "(table,instance_no)",
+      "cimguiname": "igTableGetInstanceData",
+      "defaults": {},
+      "funcname": "TableGetInstanceData",
+      "location": "imgui_internal:3609",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetInstanceData",
+      "ret": "ImGuiTableInstanceData*",
+      "signature": "(ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableGetInstanceID": [
+    {
+      "args": "(ImGuiTable* table,int instance_no)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "instance_no",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,int instance_no)",
+      "call_args": "(table,instance_no)",
+      "cimguiname": "igTableGetInstanceID",
+      "defaults": {},
+      "funcname": "TableGetInstanceID",
+      "location": "imgui_internal:3610",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetInstanceID",
+      "ret": "ImGuiID",
+      "signature": "(ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableGetRowIndex": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetRowIndex",
+      "defaults": {},
+      "funcname": "TableGetRowIndex",
+      "location": "imgui:849",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetRowIndex",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableGetSortSpecs": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableGetSortSpecs",
+      "defaults": {},
+      "funcname": "TableGetSortSpecs",
+      "location": "imgui:846",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableGetSortSpecs",
+      "ret": "ImGuiTableSortSpecs*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableHeader": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igTableHeader",
+      "defaults": {},
+      "funcname": "TableHeader",
+      "location": "imgui:836",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableHeader",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igTableHeadersRow": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableHeadersRow",
+      "defaults": {},
+      "funcname": "TableHeadersRow",
+      "location": "imgui:837",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableHeadersRow",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableLoadSettings": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableLoadSettings",
+      "defaults": {},
+      "funcname": "TableLoadSettings",
+      "location": "imgui_internal:3632",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableLoadSettings",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableMergeDrawChannels": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableMergeDrawChannels",
+      "defaults": {},
+      "funcname": "TableMergeDrawChannels",
+      "location": "imgui_internal:3608",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableMergeDrawChannels",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableNextColumn": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableNextColumn",
+      "defaults": {},
+      "funcname": "TableNextColumn",
+      "location": "imgui:823",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableNextColumn",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableNextRow": [
+    {
+      "args": "(ImGuiTableRowFlags row_flags,float min_row_height)",
+      "argsT": [
+        {
+          "name": "row_flags",
+          "type": "ImGuiTableRowFlags"
+        },
+        {
+          "name": "min_row_height",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImGuiTableRowFlags row_flags=0,float min_row_height=0.0f)",
+      "call_args": "(row_flags,min_row_height)",
+      "cimguiname": "igTableNextRow",
+      "defaults": {
+        "min_row_height": "0.0f",
+        "row_flags": "0"
+      },
+      "funcname": "TableNextRow",
+      "location": "imgui:822",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableNextRow",
+      "ret": "void",
+      "signature": "(ImGuiTableRowFlags,float)",
+      "stname": ""
+    }
+  ],
+  "igTableOpenContextMenu": [
+    {
+      "args": "(int column_n)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_n=-1)",
+      "call_args": "(column_n)",
+      "cimguiname": "igTableOpenContextMenu",
+      "defaults": {
+        "column_n": "-1"
+      },
+      "funcname": "TableOpenContextMenu",
+      "location": "imgui_internal:3585",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableOpenContextMenu",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igTablePopBackgroundChannel": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTablePopBackgroundChannel",
+      "defaults": {},
+      "funcname": "TablePopBackgroundChannel",
+      "location": "imgui_internal:3592",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTablePopBackgroundChannel",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTablePushBackgroundChannel": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTablePushBackgroundChannel",
+      "defaults": {},
+      "funcname": "TablePushBackgroundChannel",
+      "location": "imgui_internal:3591",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTablePushBackgroundChannel",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableRemove": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableRemove",
+      "defaults": {},
+      "funcname": "TableRemove",
+      "location": "imgui_internal:3626",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableRemove",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableResetSettings": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableResetSettings",
+      "defaults": {},
+      "funcname": "TableResetSettings",
+      "location": "imgui_internal:3634",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableResetSettings",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableSaveSettings": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableSaveSettings",
+      "defaults": {},
+      "funcname": "TableSaveSettings",
+      "location": "imgui_internal:3633",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSaveSettings",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableSetBgColor": [
+    {
+      "args": "(ImGuiTableBgTarget target,ImU32 color,int column_n)",
+      "argsT": [
+        {
+          "name": "target",
+          "type": "ImGuiTableBgTarget"
+        },
+        {
+          "name": "color",
+          "type": "ImU32"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTableBgTarget target,ImU32 color,int column_n=-1)",
+      "call_args": "(target,color,column_n)",
+      "cimguiname": "igTableSetBgColor",
+      "defaults": {
+        "column_n": "-1"
+      },
+      "funcname": "TableSetBgColor",
+      "location": "imgui:854",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetBgColor",
+      "ret": "void",
+      "signature": "(ImGuiTableBgTarget,ImU32,int)",
+      "stname": ""
+    }
+  ],
+  "igTableSetColumnEnabled": [
+    {
+      "args": "(int column_n,bool v)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        },
+        {
+          "name": "v",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(int column_n,bool v)",
+      "call_args": "(column_n,v)",
+      "cimguiname": "igTableSetColumnEnabled",
+      "defaults": {},
+      "funcname": "TableSetColumnEnabled",
+      "location": "imgui:852",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetColumnEnabled",
+      "ret": "void",
+      "signature": "(int,bool)",
+      "stname": ""
+    }
+  ],
+  "igTableSetColumnIndex": [
+    {
+      "args": "(int column_n)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int column_n)",
+      "call_args": "(column_n)",
+      "cimguiname": "igTableSetColumnIndex",
+      "defaults": {},
+      "funcname": "TableSetColumnIndex",
+      "location": "imgui:824",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetColumnIndex",
+      "ret": "bool",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "igTableSetColumnSortDirection": [
+    {
+      "args": "(int column_n,ImGuiSortDirection sort_direction,bool append_to_sort_specs)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        },
+        {
+          "name": "sort_direction",
+          "type": "ImGuiSortDirection"
+        },
+        {
+          "name": "append_to_sort_specs",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(int column_n,ImGuiSortDirection sort_direction,bool append_to_sort_specs)",
+      "call_args": "(column_n,sort_direction,append_to_sort_specs)",
+      "cimguiname": "igTableSetColumnSortDirection",
+      "defaults": {},
+      "funcname": "TableSetColumnSortDirection",
+      "location": "imgui_internal:3587",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetColumnSortDirection",
+      "ret": "void",
+      "signature": "(int,ImGuiSortDirection,bool)",
+      "stname": ""
+    }
+  ],
+  "igTableSetColumnWidth": [
+    {
+      "args": "(int column_n,float width)",
+      "argsT": [
+        {
+          "name": "column_n",
+          "type": "int"
+        },
+        {
+          "name": "width",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(int column_n,float width)",
+      "call_args": "(column_n,width)",
+      "cimguiname": "igTableSetColumnWidth",
+      "defaults": {},
+      "funcname": "TableSetColumnWidth",
+      "location": "imgui_internal:3586",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetColumnWidth",
+      "ret": "void",
+      "signature": "(int,float)",
+      "stname": ""
+    }
+  ],
+  "igTableSetColumnWidthAutoAll": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableSetColumnWidthAutoAll",
+      "defaults": {},
+      "funcname": "TableSetColumnWidthAutoAll",
+      "location": "imgui_internal:3625",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetColumnWidthAutoAll",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableSetColumnWidthAutoSingle": [
+    {
+      "args": "(ImGuiTable* table,int column_n)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        },
+        {
+          "name": "column_n",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table,int column_n)",
+      "call_args": "(table,column_n)",
+      "cimguiname": "igTableSetColumnWidthAutoSingle",
+      "defaults": {},
+      "funcname": "TableSetColumnWidthAutoSingle",
+      "location": "imgui_internal:3624",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetColumnWidthAutoSingle",
+      "ret": "void",
+      "signature": "(ImGuiTable*,int)",
+      "stname": ""
+    }
+  ],
+  "igTableSettingsAddSettingsHandler": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTableSettingsAddSettingsHandler",
+      "defaults": {},
+      "funcname": "TableSettingsAddSettingsHandler",
+      "location": "imgui_internal:3636",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSettingsAddSettingsHandler",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTableSettingsCreate": [
+    {
+      "args": "(ImGuiID id,int columns_count)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "columns_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,int columns_count)",
+      "call_args": "(id,columns_count)",
+      "cimguiname": "igTableSettingsCreate",
+      "defaults": {},
+      "funcname": "TableSettingsCreate",
+      "location": "imgui_internal:3637",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSettingsCreate",
+      "ret": "ImGuiTableSettings*",
+      "signature": "(ImGuiID,int)",
+      "stname": ""
+    }
+  ],
+  "igTableSettingsFindByID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igTableSettingsFindByID",
+      "defaults": {},
+      "funcname": "TableSettingsFindByID",
+      "location": "imgui_internal:3638",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSettingsFindByID",
+      "ret": "ImGuiTableSettings*",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTableSetupColumn": [
+    {
+      "args": "(const char* label,ImGuiTableColumnFlags flags,float init_width_or_weight,ImGuiID user_id)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTableColumnFlags"
+        },
+        {
+          "name": "init_width_or_weight",
+          "type": "float"
+        },
+        {
+          "name": "user_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiTableColumnFlags flags=0,float init_width_or_weight=0.0f,ImGuiID user_id=0)",
+      "call_args": "(label,flags,init_width_or_weight,user_id)",
+      "cimguiname": "igTableSetupColumn",
+      "defaults": {
+        "flags": "0",
+        "init_width_or_weight": "0.0f",
+        "user_id": "0"
+      },
+      "funcname": "TableSetupColumn",
+      "location": "imgui:834",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetupColumn",
+      "ret": "void",
+      "signature": "(const char*,ImGuiTableColumnFlags,float,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTableSetupDrawChannels": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableSetupDrawChannels",
+      "defaults": {},
+      "funcname": "TableSetupDrawChannels",
+      "location": "imgui_internal:3601",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetupDrawChannels",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableSetupScrollFreeze": [
+    {
+      "args": "(int cols,int rows)",
+      "argsT": [
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int cols,int rows)",
+      "call_args": "(cols,rows)",
+      "cimguiname": "igTableSetupScrollFreeze",
+      "defaults": {},
+      "funcname": "TableSetupScrollFreeze",
+      "location": "imgui:835",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSetupScrollFreeze",
+      "ret": "void",
+      "signature": "(int,int)",
+      "stname": ""
+    }
+  ],
+  "igTableSortSpecsBuild": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableSortSpecsBuild",
+      "defaults": {},
+      "funcname": "TableSortSpecsBuild",
+      "location": "imgui_internal:3612",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSortSpecsBuild",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableSortSpecsSanitize": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableSortSpecsSanitize",
+      "defaults": {},
+      "funcname": "TableSortSpecsSanitize",
+      "location": "imgui_internal:3611",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableSortSpecsSanitize",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableUpdateBorders": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableUpdateBorders",
+      "defaults": {},
+      "funcname": "TableUpdateBorders",
+      "location": "imgui_internal:3603",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableUpdateBorders",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableUpdateColumnsWeightFromWidth": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableUpdateColumnsWeightFromWidth",
+      "defaults": {},
+      "funcname": "TableUpdateColumnsWeightFromWidth",
+      "location": "imgui_internal:3604",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableUpdateColumnsWeightFromWidth",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTableUpdateLayout": [
+    {
+      "args": "(ImGuiTable* table)",
+      "argsT": [
+        {
+          "name": "table",
+          "type": "ImGuiTable*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTable* table)",
+      "call_args": "(table)",
+      "cimguiname": "igTableUpdateLayout",
+      "defaults": {},
+      "funcname": "TableUpdateLayout",
+      "location": "imgui_internal:3602",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTableUpdateLayout",
+      "ret": "void",
+      "signature": "(ImGuiTable*)",
+      "stname": ""
+    }
+  ],
+  "igTeleportMousePos": [
+    {
+      "args": "(const ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos)",
+      "call_args": "(pos)",
+      "cimguiname": "igTeleportMousePos",
+      "defaults": {},
+      "funcname": "TeleportMousePos",
+      "location": "imgui_internal:3422",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTeleportMousePos",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igTempInputIsActive": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igTempInputIsActive",
+      "defaults": {},
+      "funcname": "TempInputIsActive",
+      "location": "imgui_internal:3748",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTempInputIsActive",
+      "ret": "bool",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTempInputScalar": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format,const void* p_clamp_min,const void* p_clamp_max)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "p_clamp_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_clamp_max",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format,const void* p_clamp_min=((void*)0),const void* p_clamp_max=((void*)0))",
+      "call_args": "(bb,id,label,data_type,p_data,format,p_clamp_min,p_clamp_max)",
+      "cimguiname": "igTempInputScalar",
+      "defaults": {
+        "p_clamp_max": "NULL",
+        "p_clamp_min": "NULL"
+      },
+      "funcname": "TempInputScalar",
+      "location": "imgui_internal:3747",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTempInputScalar",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,const char*,ImGuiDataType,void*,const char*,const void*,const void*)",
+      "stname": ""
+    }
+  ],
+  "igTempInputText": [
+    {
+      "args": "(const ImRect bb,ImGuiID id,const char* label,char* buf,int buf_size,ImGuiInputTextFlags flags)",
+      "argsT": [
+        {
+          "name": "bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "buf",
+          "type": "char*"
+        },
+        {
+          "name": "buf_size",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiInputTextFlags"
+        }
+      ],
+      "argsoriginal": "(const ImRect& bb,ImGuiID id,const char* label,char* buf,int buf_size,ImGuiInputTextFlags flags)",
+      "call_args": "(bb,id,label,buf,buf_size,flags)",
+      "cimguiname": "igTempInputText",
+      "defaults": {},
+      "funcname": "TempInputText",
+      "location": "imgui_internal:3746",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTempInputText",
+      "ret": "bool",
+      "signature": "(const ImRect,ImGuiID,const char*,char*,int,ImGuiInputTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igTestKeyOwner": [
+    {
+      "args": "(ImGuiKey key,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key",
+          "type": "ImGuiKey"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKey key,ImGuiID owner_id)",
+      "call_args": "(key,owner_id)",
+      "cimguiname": "igTestKeyOwner",
+      "defaults": {},
+      "funcname": "TestKeyOwner",
+      "location": "imgui_internal:3441",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTestKeyOwner",
+      "ret": "bool",
+      "signature": "(ImGuiKey,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTestShortcutRouting": [
+    {
+      "args": "(ImGuiKeyChord key_chord,ImGuiID owner_id)",
+      "argsT": [
+        {
+          "name": "key_chord",
+          "type": "ImGuiKeyChord"
+        },
+        {
+          "name": "owner_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiKeyChord key_chord,ImGuiID owner_id)",
+      "call_args": "(key_chord,owner_id)",
+      "cimguiname": "igTestShortcutRouting",
+      "defaults": {},
+      "funcname": "TestShortcutRouting",
+      "location": "imgui_internal:3475",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTestShortcutRouting",
+      "ret": "bool",
+      "signature": "(ImGuiKeyChord,ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igText": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igText",
+      "defaults": {},
+      "funcname": "Text",
+      "isvararg": "...)",
+      "location": "imgui:540",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igText",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igTextColored": [
+    {
+      "args": "(const ImVec4 col,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col,const char* fmt,...)",
+      "call_args": "(col,fmt,...)",
+      "cimguiname": "igTextColored",
+      "defaults": {},
+      "funcname": "TextColored",
+      "isvararg": "...)",
+      "location": "imgui:542",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextColored",
+      "ret": "void",
+      "signature": "(const ImVec4,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igTextColoredV": [
+    {
+      "args": "(const ImVec4 col,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col,const char* fmt,va_list args)",
+      "call_args": "(col,fmt,args)",
+      "cimguiname": "igTextColoredV",
+      "defaults": {},
+      "funcname": "TextColoredV",
+      "location": "imgui:543",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextColoredV",
+      "ret": "void",
+      "signature": "(const ImVec4,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igTextDisabled": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igTextDisabled",
+      "defaults": {},
+      "funcname": "TextDisabled",
+      "isvararg": "...)",
+      "location": "imgui:544",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextDisabled",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igTextDisabledV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igTextDisabledV",
+      "defaults": {},
+      "funcname": "TextDisabledV",
+      "location": "imgui:545",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextDisabledV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igTextEx": [
+    {
+      "args": "(const char* text,const char* text_end,ImGuiTextFlags flags)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* text,const char* text_end=((void*)0),ImGuiTextFlags flags=0)",
+      "call_args": "(text,text_end,flags)",
+      "cimguiname": "igTextEx",
+      "defaults": {
+        "flags": "0",
+        "text_end": "NULL"
+      },
+      "funcname": "TextEx",
+      "location": "imgui_internal:3692",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextEx",
+      "ret": "void",
+      "signature": "(const char*,const char*,ImGuiTextFlags)",
+      "stname": ""
+    }
+  ],
+  "igTextLink": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igTextLink",
+      "defaults": {},
+      "funcname": "TextLink",
+      "location": "imgui:568",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextLink",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "igTextLinkOpenURL": [
+    {
+      "args": "(const char* label,const char* url)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "url",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label,const char* url=((void*)0))",
+      "call_args": "(label,url)",
+      "cimguiname": "igTextLinkOpenURL",
+      "defaults": {
+        "url": "NULL"
+      },
+      "funcname": "TextLinkOpenURL",
+      "location": "imgui:569",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextLinkOpenURL",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igTextUnformatted": [
+    {
+      "args": "(const char* text,const char* text_end)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text,const char* text_end=((void*)0))",
+      "call_args": "(text,text_end)",
+      "cimguiname": "igTextUnformatted",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "TextUnformatted",
+      "location": "imgui:539",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextUnformatted",
+      "ret": "void",
+      "signature": "(const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igTextV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igTextV",
+      "defaults": {},
+      "funcname": "TextV",
+      "location": "imgui:541",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igTextWrapped": [
+    {
+      "args": "(const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* fmt,...)",
+      "call_args": "(fmt,...)",
+      "cimguiname": "igTextWrapped",
+      "defaults": {},
+      "funcname": "TextWrapped",
+      "isvararg": "...)",
+      "location": "imgui:546",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextWrapped",
+      "ret": "void",
+      "signature": "(const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igTextWrappedV": [
+    {
+      "args": "(const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* fmt,va_list args)",
+      "call_args": "(fmt,args)",
+      "cimguiname": "igTextWrappedV",
+      "defaults": {},
+      "funcname": "TextWrappedV",
+      "location": "imgui:547",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTextWrappedV",
+      "ret": "void",
+      "signature": "(const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igTranslateWindowsInViewport": [
+    {
+      "args": "(ImGuiViewportP* viewport,const ImVec2 old_pos,const ImVec2 new_pos,const ImVec2 old_size,const ImVec2 new_size)",
+      "argsT": [
+        {
+          "name": "viewport",
+          "type": "ImGuiViewportP*"
+        },
+        {
+          "name": "old_pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "new_pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "old_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "new_size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiViewportP* viewport,const ImVec2& old_pos,const ImVec2& new_pos,const ImVec2& old_size,const ImVec2& new_size)",
+      "call_args": "(viewport,old_pos,new_pos,old_size,new_size)",
+      "cimguiname": "igTranslateWindowsInViewport",
+      "defaults": {},
+      "funcname": "TranslateWindowsInViewport",
+      "location": "imgui_internal:3257",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTranslateWindowsInViewport",
+      "ret": "void",
+      "signature": "(ImGuiViewportP*,const ImVec2,const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igTreeNode": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "igTreeNode",
+      "defaults": {},
+      "funcname": "TreeNode",
+      "location": "imgui:664",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNode_Str",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* str_id,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* str_id,const char* fmt,...)",
+      "call_args": "(str_id,fmt,...)",
+      "cimguiname": "igTreeNode",
+      "defaults": {},
+      "funcname": "TreeNode",
+      "isvararg": "...)",
+      "location": "imgui:665",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNode_StrStr",
+      "ret": "bool",
+      "signature": "(const char*,const char*,...)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id,const char* fmt,...)",
+      "call_args": "(ptr_id,fmt,...)",
+      "cimguiname": "igTreeNode",
+      "defaults": {},
+      "funcname": "TreeNode",
+      "isvararg": "...)",
+      "location": "imgui:666",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNode_Ptr",
+      "ret": "bool",
+      "signature": "(const void*,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeBehavior": [
+    {
+      "args": "(ImGuiID id,ImGuiTreeNodeFlags flags,const char* label,const char* label_end)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "label_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id,ImGuiTreeNodeFlags flags,const char* label,const char* label_end=((void*)0))",
+      "call_args": "(id,flags,label,label_end)",
+      "cimguiname": "igTreeNodeBehavior",
+      "defaults": {
+        "label_end": "NULL"
+      },
+      "funcname": "TreeNodeBehavior",
+      "location": "imgui_internal:3718",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeBehavior",
+      "ret": "bool",
+      "signature": "(ImGuiID,ImGuiTreeNodeFlags,const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeEx": [
+    {
+      "args": "(const char* label,ImGuiTreeNodeFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,ImGuiTreeNodeFlags flags=0)",
+      "call_args": "(label,flags)",
+      "cimguiname": "igTreeNodeEx",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "TreeNodeEx",
+      "location": "imgui:669",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeEx_Str",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiTreeNodeFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
+      "call_args": "(str_id,flags,fmt,...)",
+      "cimguiname": "igTreeNodeEx",
+      "defaults": {},
+      "funcname": "TreeNodeEx",
+      "isvararg": "...)",
+      "location": "imgui:670",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeEx_StrStr",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiTreeNodeFlags,const char*,...)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...)",
+      "call_args": "(ptr_id,flags,fmt,...)",
+      "cimguiname": "igTreeNodeEx",
+      "defaults": {},
+      "funcname": "TreeNodeEx",
+      "isvararg": "...)",
+      "location": "imgui:671",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeEx_Ptr",
+      "ret": "bool",
+      "signature": "(const void*,ImGuiTreeNodeFlags,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeExV": [
+    {
+      "args": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
+      "call_args": "(str_id,flags,fmt,args)",
+      "cimguiname": "igTreeNodeExV",
+      "defaults": {},
+      "funcname": "TreeNodeExV",
+      "location": "imgui:672",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeExV_Str",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiTreeNodeFlags,const char*,va_list)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args)",
+      "call_args": "(ptr_id,flags,fmt,args)",
+      "cimguiname": "igTreeNodeExV",
+      "defaults": {},
+      "funcname": "TreeNodeExV",
+      "location": "imgui:673",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeExV_Ptr",
+      "ret": "bool",
+      "signature": "(const void*,ImGuiTreeNodeFlags,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeGetOpen": [
+    {
+      "args": "(ImGuiID storage_id)",
+      "argsT": [
+        {
+          "name": "storage_id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID storage_id)",
+      "call_args": "(storage_id)",
+      "cimguiname": "igTreeNodeGetOpen",
+      "defaults": {},
+      "funcname": "TreeNodeGetOpen",
+      "location": "imgui_internal:3720",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeGetOpen",
+      "ret": "bool",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeSetOpen": [
+    {
+      "args": "(ImGuiID storage_id,bool open)",
+      "argsT": [
+        {
+          "name": "storage_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "open",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImGuiID storage_id,bool open)",
+      "call_args": "(storage_id,open)",
+      "cimguiname": "igTreeNodeSetOpen",
+      "defaults": {},
+      "funcname": "TreeNodeSetOpen",
+      "location": "imgui_internal:3721",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeSetOpen",
+      "ret": "void",
+      "signature": "(ImGuiID,bool)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeUpdateNextOpen": [
+    {
+      "args": "(ImGuiID storage_id,ImGuiTreeNodeFlags flags)",
+      "argsT": [
+        {
+          "name": "storage_id",
+          "type": "ImGuiID"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiTreeNodeFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiID storage_id,ImGuiTreeNodeFlags flags)",
+      "call_args": "(storage_id,flags)",
+      "cimguiname": "igTreeNodeUpdateNextOpen",
+      "defaults": {},
+      "funcname": "TreeNodeUpdateNextOpen",
+      "location": "imgui_internal:3722",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeUpdateNextOpen",
+      "ret": "bool",
+      "signature": "(ImGuiID,ImGuiTreeNodeFlags)",
+      "stname": ""
+    }
+  ],
+  "igTreeNodeV": [
+    {
+      "args": "(const char* str_id,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const char* str_id,const char* fmt,va_list args)",
+      "call_args": "(str_id,fmt,args)",
+      "cimguiname": "igTreeNodeV",
+      "defaults": {},
+      "funcname": "TreeNodeV",
+      "location": "imgui:667",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeV_Str",
+      "ret": "bool",
+      "signature": "(const char*,const char*,va_list)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id,const char* fmt,va_list args)",
+      "call_args": "(ptr_id,fmt,args)",
+      "cimguiname": "igTreeNodeV",
+      "defaults": {},
+      "funcname": "TreeNodeV",
+      "location": "imgui:668",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreeNodeV_Ptr",
+      "ret": "bool",
+      "signature": "(const void*,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "igTreePop": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igTreePop",
+      "defaults": {},
+      "funcname": "TreePop",
+      "location": "imgui:676",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreePop",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igTreePush": [
+    {
+      "args": "(const char* str_id)",
+      "argsT": [
+        {
+          "name": "str_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* str_id)",
+      "call_args": "(str_id)",
+      "cimguiname": "igTreePush",
+      "defaults": {},
+      "funcname": "TreePush",
+      "location": "imgui:674",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreePush_Str",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(const void* ptr_id)",
+      "argsT": [
+        {
+          "name": "ptr_id",
+          "type": "const void*"
+        }
+      ],
+      "argsoriginal": "(const void* ptr_id)",
+      "call_args": "(ptr_id)",
+      "cimguiname": "igTreePush",
+      "defaults": {},
+      "funcname": "TreePush",
+      "location": "imgui:675",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreePush_Ptr",
+      "ret": "void",
+      "signature": "(const void*)",
+      "stname": ""
+    }
+  ],
+  "igTreePushOverrideID": [
+    {
+      "args": "(ImGuiID id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "igTreePushOverrideID",
+      "defaults": {},
+      "funcname": "TreePushOverrideID",
+      "location": "imgui_internal:3719",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTreePushOverrideID",
+      "ret": "void",
+      "signature": "(ImGuiID)",
+      "stname": ""
+    }
+  ],
+  "igTypingSelectFindBestLeadingMatch": [
+    {
+      "args": "(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data)",
+      "argsT": [
+        {
+          "name": "req",
+          "type": "ImGuiTypingSelectRequest*"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "get_item_name_func",
+          "ret": "const char*",
+          "signature": "(void*,int)",
+          "type": "const char*(*)(void*,int)"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data)",
+      "call_args": "(req,items_count,get_item_name_func,user_data)",
+      "cimguiname": "igTypingSelectFindBestLeadingMatch",
+      "defaults": {},
+      "funcname": "TypingSelectFindBestLeadingMatch",
+      "location": "imgui_internal:3558",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTypingSelectFindBestLeadingMatch",
+      "ret": "int",
+      "signature": "(ImGuiTypingSelectRequest*,int,const char*(*)(void*,int),void*)",
+      "stname": ""
+    }
+  ],
+  "igTypingSelectFindMatch": [
+    {
+      "args": "(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data,int nav_item_idx)",
+      "argsT": [
+        {
+          "name": "req",
+          "type": "ImGuiTypingSelectRequest*"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "get_item_name_func",
+          "ret": "const char*",
+          "signature": "(void*,int)",
+          "type": "const char*(*)(void*,int)"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        },
+        {
+          "name": "nav_item_idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data,int nav_item_idx)",
+      "call_args": "(req,items_count,get_item_name_func,user_data,nav_item_idx)",
+      "cimguiname": "igTypingSelectFindMatch",
+      "defaults": {},
+      "funcname": "TypingSelectFindMatch",
+      "location": "imgui_internal:3556",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTypingSelectFindMatch",
+      "ret": "int",
+      "signature": "(ImGuiTypingSelectRequest*,int,const char*(*)(void*,int),void*,int)",
+      "stname": ""
+    }
+  ],
+  "igTypingSelectFindNextSingleCharMatch": [
+    {
+      "args": "(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data,int nav_item_idx)",
+      "argsT": [
+        {
+          "name": "req",
+          "type": "ImGuiTypingSelectRequest*"
+        },
+        {
+          "name": "items_count",
+          "type": "int"
+        },
+        {
+          "name": "get_item_name_func",
+          "ret": "const char*",
+          "signature": "(void*,int)",
+          "type": "const char*(*)(void*,int)"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        },
+        {
+          "name": "nav_item_idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImGuiTypingSelectRequest* req,int items_count,const char*(*get_item_name_func)(void*,int),void* user_data,int nav_item_idx)",
+      "call_args": "(req,items_count,get_item_name_func,user_data,nav_item_idx)",
+      "cimguiname": "igTypingSelectFindNextSingleCharMatch",
+      "defaults": {},
+      "funcname": "TypingSelectFindNextSingleCharMatch",
+      "location": "imgui_internal:3557",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igTypingSelectFindNextSingleCharMatch",
+      "ret": "int",
+      "signature": "(ImGuiTypingSelectRequest*,int,const char*(*)(void*,int),void*,int)",
+      "stname": ""
+    }
+  ],
+  "igUnindent": [
+    {
+      "args": "(float indent_w)",
+      "argsT": [
+        {
+          "name": "indent_w",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float indent_w=0.0f)",
+      "call_args": "(indent_w)",
+      "cimguiname": "igUnindent",
+      "defaults": {
+        "indent_w": "0.0f"
+      },
+      "funcname": "Unindent",
+      "location": "imgui:508",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUnindent",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "igUpdateHoveredWindowAndCaptureFlags": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igUpdateHoveredWindowAndCaptureFlags",
+      "defaults": {},
+      "funcname": "UpdateHoveredWindowAndCaptureFlags",
+      "location": "imgui_internal:3244",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdateHoveredWindowAndCaptureFlags",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igUpdateInputEvents": [
+    {
+      "args": "(bool trickle_fast_inputs)",
+      "argsT": [
+        {
+          "name": "trickle_fast_inputs",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool trickle_fast_inputs)",
+      "call_args": "(trickle_fast_inputs)",
+      "cimguiname": "igUpdateInputEvents",
+      "defaults": {},
+      "funcname": "UpdateInputEvents",
+      "location": "imgui_internal:3243",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdateInputEvents",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "igUpdateMouseMovingWindowEndFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igUpdateMouseMovingWindowEndFrame",
+      "defaults": {},
+      "funcname": "UpdateMouseMovingWindowEndFrame",
+      "location": "imgui_internal:3249",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdateMouseMovingWindowEndFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igUpdateMouseMovingWindowNewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igUpdateMouseMovingWindowNewFrame",
+      "defaults": {},
+      "funcname": "UpdateMouseMovingWindowNewFrame",
+      "location": "imgui_internal:3248",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdateMouseMovingWindowNewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igUpdatePlatformWindows": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "igUpdatePlatformWindows",
+      "defaults": {},
+      "funcname": "UpdatePlatformWindows",
+      "location": "imgui:1088",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdatePlatformWindows",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "igUpdateWindowParentAndRootLinks": [
+    {
+      "args": "(ImGuiWindow* window,ImGuiWindowFlags flags,ImGuiWindow* parent_window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiWindowFlags"
+        },
+        {
+          "name": "parent_window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,ImGuiWindowFlags flags,ImGuiWindow* parent_window)",
+      "call_args": "(window,flags,parent_window)",
+      "cimguiname": "igUpdateWindowParentAndRootLinks",
+      "defaults": {},
+      "funcname": "UpdateWindowParentAndRootLinks",
+      "location": "imgui_internal:3201",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdateWindowParentAndRootLinks",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,ImGuiWindowFlags,ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igUpdateWindowSkipRefresh": [
+    {
+      "args": "(ImGuiWindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "igUpdateWindowSkipRefresh",
+      "defaults": {},
+      "funcname": "UpdateWindowSkipRefresh",
+      "location": "imgui_internal:3202",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igUpdateWindowSkipRefresh",
+      "ret": "void",
+      "signature": "(ImGuiWindow*)",
+      "stname": ""
+    }
+  ],
+  "igVSliderFloat": [
+    {
+      "args": "(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "v",
+          "type": "float*"
+        },
+        {
+          "name": "v_min",
+          "type": "float"
+        },
+        {
+          "name": "v_max",
+          "type": "float"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size,float* v,float v_min,float v_max,const char* format=\"%.3f\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,size,v,v_min,v_max,format,flags)",
+      "cimguiname": "igVSliderFloat",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%.3f\""
+      },
+      "funcname": "VSliderFloat",
+      "location": "imgui:630",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igVSliderFloat",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,float*,float,float,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igVSliderInt": [
+    {
+      "args": "(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "v",
+          "type": "int*"
+        },
+        {
+          "name": "v_min",
+          "type": "int"
+        },
+        {
+          "name": "v_max",
+          "type": "int"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size,int* v,int v_min,int v_max,const char* format=\"%d\",ImGuiSliderFlags flags=0)",
+      "call_args": "(label,size,v,v_min,v_max,format,flags)",
+      "cimguiname": "igVSliderInt",
+      "defaults": {
+        "flags": "0",
+        "format": "\"%d\""
+      },
+      "funcname": "VSliderInt",
+      "location": "imgui:631",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igVSliderInt",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,int*,int,int,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igVSliderScalar": [
+    {
+      "args": "(const char* label,const ImVec2 size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format,ImGuiSliderFlags flags)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "data_type",
+          "type": "ImGuiDataType"
+        },
+        {
+          "name": "p_data",
+          "type": "void*"
+        },
+        {
+          "name": "p_min",
+          "type": "const void*"
+        },
+        {
+          "name": "p_max",
+          "type": "const void*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiSliderFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size,ImGuiDataType data_type,void* p_data,const void* p_min,const void* p_max,const char* format=((void*)0),ImGuiSliderFlags flags=0)",
+      "call_args": "(label,size,data_type,p_data,p_min,p_max,format,flags)",
+      "cimguiname": "igVSliderScalar",
+      "defaults": {
+        "flags": "0",
+        "format": "NULL"
+      },
+      "funcname": "VSliderScalar",
+      "location": "imgui:632",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igVSliderScalar",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,ImGuiDataType,void*,const void*,const void*,const char*,ImGuiSliderFlags)",
+      "stname": ""
+    }
+  ],
+  "igValue": [
+    {
+      "args": "(const char* prefix,bool b)",
+      "argsT": [
+        {
+          "name": "prefix",
+          "type": "const char*"
+        },
+        {
+          "name": "b",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* prefix,bool b)",
+      "call_args": "(prefix,b)",
+      "cimguiname": "igValue",
+      "defaults": {},
+      "funcname": "Value",
+      "location": "imgui:721",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igValue_Bool",
+      "ret": "void",
+      "signature": "(const char*,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* prefix,int v)",
+      "argsT": [
+        {
+          "name": "prefix",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* prefix,int v)",
+      "call_args": "(prefix,v)",
+      "cimguiname": "igValue",
+      "defaults": {},
+      "funcname": "Value",
+      "location": "imgui:722",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igValue_Int",
+      "ret": "void",
+      "signature": "(const char*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* prefix,unsigned int v)",
+      "argsT": [
+        {
+          "name": "prefix",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(const char* prefix,unsigned int v)",
+      "call_args": "(prefix,v)",
+      "cimguiname": "igValue",
+      "defaults": {},
+      "funcname": "Value",
+      "location": "imgui:723",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igValue_Uint",
+      "ret": "void",
+      "signature": "(const char*,unsigned int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* prefix,float v,const char* float_format)",
+      "argsT": [
+        {
+          "name": "prefix",
+          "type": "const char*"
+        },
+        {
+          "name": "v",
+          "type": "float"
+        },
+        {
+          "name": "float_format",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* prefix,float v,const char* float_format=((void*)0))",
+      "call_args": "(prefix,v,float_format)",
+      "cimguiname": "igValue",
+      "defaults": {
+        "float_format": "NULL"
+      },
+      "funcname": "Value",
+      "location": "imgui:724",
+      "namespace": "ImGui",
+      "ov_cimguiname": "igValue_Float",
+      "ret": "void",
+      "signature": "(const char*,float,const char*)",
+      "stname": ""
+    }
+  ],
+  "igWindowPosAbsToRel": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImVec2& p)",
+      "call_args": "(window,p)",
+      "cimguiname": "igWindowPosAbsToRel",
+      "defaults": {},
+      "funcname": "WindowPosAbsToRel",
+      "location": "imgui_internal:3216",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igWindowPosAbsToRel",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igWindowPosRelToAbs": [
+    {
+      "args": "(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImVec2& p)",
+      "call_args": "(window,p)",
+      "cimguiname": "igWindowPosRelToAbs",
+      "defaults": {},
+      "funcname": "WindowPosRelToAbs",
+      "location": "imgui_internal:3217",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igWindowPosRelToAbs",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "igWindowRectAbsToRel": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* window,const ImRect r)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImRect& r)",
+      "call_args": "(window,r)",
+      "cimguiname": "igWindowRectAbsToRel",
+      "defaults": {},
+      "funcname": "WindowRectAbsToRel",
+      "location": "imgui_internal:3214",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igWindowRectAbsToRel",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImRect)",
+      "stname": ""
+    }
+  ],
+  "igWindowRectRelToAbs": [
+    {
+      "args": "(ImRect *pOut,ImGuiWindow* window,const ImRect r)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImRect*"
+        },
+        {
+          "name": "window",
+          "type": "ImGuiWindow*"
+        },
+        {
+          "name": "r",
+          "type": "const ImRect"
+        }
+      ],
+      "argsoriginal": "(ImGuiWindow* window,const ImRect& r)",
+      "call_args": "(window,r)",
+      "cimguiname": "igWindowRectRelToAbs",
+      "defaults": {},
+      "funcname": "WindowRectRelToAbs",
+      "location": "imgui_internal:3215",
+      "namespace": "ImGui",
+      "nonUDT": 1,
+      "ov_cimguiname": "igWindowRectRelToAbs",
+      "ret": "void",
+      "signature": "(ImGuiWindow*,const ImRect)",
+      "stname": ""
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimgui/structs_and_enums.json b/src/CodeGenerator/definitions/cimgui/structs_and_enums.json
new file mode 100644
index 00000000..af4542a5
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimgui/structs_and_enums.json
@@ -0,0 +1,12151 @@
+{
+  "enums": {
+    "ImDrawFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImDrawFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImDrawFlags_Closed",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImDrawFlags_RoundCornersTopLeft",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImDrawFlags_RoundCornersTopRight",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImDrawFlags_RoundCornersBottomLeft",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImDrawFlags_RoundCornersBottomRight",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImDrawFlags_RoundCornersNone",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 48,
+        "name": "ImDrawFlags_RoundCornersTop",
+        "value": "ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight"
+      },
+      {
+        "calc_value": 192,
+        "name": "ImDrawFlags_RoundCornersBottom",
+        "value": "ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersBottomRight"
+      },
+      {
+        "calc_value": 80,
+        "name": "ImDrawFlags_RoundCornersLeft",
+        "value": "ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersTopLeft"
+      },
+      {
+        "calc_value": 160,
+        "name": "ImDrawFlags_RoundCornersRight",
+        "value": "ImDrawFlags_RoundCornersBottomRight | ImDrawFlags_RoundCornersTopRight"
+      },
+      {
+        "calc_value": 240,
+        "name": "ImDrawFlags_RoundCornersAll",
+        "value": "ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight | ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersBottomRight"
+      },
+      {
+        "calc_value": 240,
+        "name": "ImDrawFlags_RoundCornersDefault_",
+        "value": "ImDrawFlags_RoundCornersAll"
+      },
+      {
+        "calc_value": 496,
+        "name": "ImDrawFlags_RoundCornersMask_",
+        "value": "ImDrawFlags_RoundCornersAll | ImDrawFlags_RoundCornersNone"
+      }
+    ],
+    "ImDrawListFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImDrawListFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImDrawListFlags_AntiAliasedLines",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImDrawListFlags_AntiAliasedLinesUseTex",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImDrawListFlags_AntiAliasedFill",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImDrawListFlags_AllowVtxOffset",
+        "value": "1 << 3"
+      }
+    ],
+    "ImFontAtlasFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImFontAtlasFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImFontAtlasFlags_NoPowerOfTwoHeight",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImFontAtlasFlags_NoMouseCursors",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImFontAtlasFlags_NoBakedLines",
+        "value": "1 << 2"
+      }
+    ],
+    "ImGuiActivateFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiActivateFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiActivateFlags_PreferInput",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiActivateFlags_PreferTweak",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiActivateFlags_TryToPreserveState",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiActivateFlags_FromTabbing",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiActivateFlags_FromShortcut",
+        "value": "1 << 4"
+      }
+    ],
+    "ImGuiAxis": [
+      {
+        "calc_value": -1,
+        "name": "ImGuiAxis_None",
+        "value": "-1"
+      },
+      {
+        "calc_value": 0,
+        "name": "ImGuiAxis_X",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiAxis_Y",
+        "value": "1"
+      }
+    ],
+    "ImGuiBackendFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiBackendFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiBackendFlags_HasGamepad",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiBackendFlags_HasMouseCursors",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiBackendFlags_HasSetMousePos",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiBackendFlags_RendererHasVtxOffset",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiBackendFlags_PlatformHasViewports",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiBackendFlags_HasMouseHoveredViewport",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiBackendFlags_RendererHasViewports",
+        "value": "1 << 12"
+      }
+    ],
+    "ImGuiButtonFlagsPrivate_": [
+      {
+        "calc_value": 16,
+        "name": "ImGuiButtonFlags_PressedOnClick",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiButtonFlags_PressedOnClickRelease",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiButtonFlags_PressedOnClickReleaseAnywhere",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiButtonFlags_PressedOnRelease",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiButtonFlags_PressedOnDoubleClick",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiButtonFlags_PressedOnDragDropHold",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiButtonFlags_FlattenChildren",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiButtonFlags_AllowOverlap",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiButtonFlags_AlignTextBaseLine",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiButtonFlags_NoKeyModsAllowed",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiButtonFlags_NoHoldingActiveId",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiButtonFlags_NoNavFocus",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 524288,
+        "name": "ImGuiButtonFlags_NoHoveredOnFocus",
+        "value": "1 << 19"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiButtonFlags_NoSetKeyOwner",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiButtonFlags_NoTestKeyOwner",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 1008,
+        "name": "ImGuiButtonFlags_PressedOnMask_",
+        "value": "ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiButtonFlags_PressedOnDefault_",
+        "value": "ImGuiButtonFlags_PressedOnClickRelease"
+      }
+    ],
+    "ImGuiButtonFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiButtonFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiButtonFlags_MouseButtonLeft",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiButtonFlags_MouseButtonRight",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiButtonFlags_MouseButtonMiddle",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiButtonFlags_MouseButtonMask_",
+        "value": "ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight | ImGuiButtonFlags_MouseButtonMiddle"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiButtonFlags_EnableNav",
+        "value": "1 << 3"
+      }
+    ],
+    "ImGuiChildFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiChildFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiChildFlags_Borders",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiChildFlags_AlwaysUseWindowPadding",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiChildFlags_ResizeX",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiChildFlags_ResizeY",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiChildFlags_AutoResizeX",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiChildFlags_AutoResizeY",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiChildFlags_AlwaysAutoResize",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiChildFlags_FrameStyle",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiChildFlags_NavFlattened",
+        "value": "1 << 8"
+      }
+    ],
+    "ImGuiCol_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiCol_Text",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiCol_TextDisabled",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiCol_WindowBg",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiCol_ChildBg",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiCol_PopupBg",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiCol_Border",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiCol_BorderShadow",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiCol_FrameBg",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiCol_FrameBgHovered",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiCol_FrameBgActive",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImGuiCol_TitleBg",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImGuiCol_TitleBgActive",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ImGuiCol_TitleBgCollapsed",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImGuiCol_MenuBarBg",
+        "value": "13"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImGuiCol_ScrollbarBg",
+        "value": "14"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImGuiCol_ScrollbarGrab",
+        "value": "15"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiCol_ScrollbarGrabHovered",
+        "value": "16"
+      },
+      {
+        "calc_value": 17,
+        "name": "ImGuiCol_ScrollbarGrabActive",
+        "value": "17"
+      },
+      {
+        "calc_value": 18,
+        "name": "ImGuiCol_CheckMark",
+        "value": "18"
+      },
+      {
+        "calc_value": 19,
+        "name": "ImGuiCol_SliderGrab",
+        "value": "19"
+      },
+      {
+        "calc_value": 20,
+        "name": "ImGuiCol_SliderGrabActive",
+        "value": "20"
+      },
+      {
+        "calc_value": 21,
+        "name": "ImGuiCol_Button",
+        "value": "21"
+      },
+      {
+        "calc_value": 22,
+        "name": "ImGuiCol_ButtonHovered",
+        "value": "22"
+      },
+      {
+        "calc_value": 23,
+        "name": "ImGuiCol_ButtonActive",
+        "value": "23"
+      },
+      {
+        "calc_value": 24,
+        "name": "ImGuiCol_Header",
+        "value": "24"
+      },
+      {
+        "calc_value": 25,
+        "name": "ImGuiCol_HeaderHovered",
+        "value": "25"
+      },
+      {
+        "calc_value": 26,
+        "name": "ImGuiCol_HeaderActive",
+        "value": "26"
+      },
+      {
+        "calc_value": 27,
+        "name": "ImGuiCol_Separator",
+        "value": "27"
+      },
+      {
+        "calc_value": 28,
+        "name": "ImGuiCol_SeparatorHovered",
+        "value": "28"
+      },
+      {
+        "calc_value": 29,
+        "name": "ImGuiCol_SeparatorActive",
+        "value": "29"
+      },
+      {
+        "calc_value": 30,
+        "name": "ImGuiCol_ResizeGrip",
+        "value": "30"
+      },
+      {
+        "calc_value": 31,
+        "name": "ImGuiCol_ResizeGripHovered",
+        "value": "31"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiCol_ResizeGripActive",
+        "value": "32"
+      },
+      {
+        "calc_value": 33,
+        "name": "ImGuiCol_TabHovered",
+        "value": "33"
+      },
+      {
+        "calc_value": 34,
+        "name": "ImGuiCol_Tab",
+        "value": "34"
+      },
+      {
+        "calc_value": 35,
+        "name": "ImGuiCol_TabSelected",
+        "value": "35"
+      },
+      {
+        "calc_value": 36,
+        "name": "ImGuiCol_TabSelectedOverline",
+        "value": "36"
+      },
+      {
+        "calc_value": 37,
+        "name": "ImGuiCol_TabDimmed",
+        "value": "37"
+      },
+      {
+        "calc_value": 38,
+        "name": "ImGuiCol_TabDimmedSelected",
+        "value": "38"
+      },
+      {
+        "calc_value": 39,
+        "name": "ImGuiCol_TabDimmedSelectedOverline",
+        "value": "39"
+      },
+      {
+        "calc_value": 40,
+        "name": "ImGuiCol_DockingPreview",
+        "value": "40"
+      },
+      {
+        "calc_value": 41,
+        "name": "ImGuiCol_DockingEmptyBg",
+        "value": "41"
+      },
+      {
+        "calc_value": 42,
+        "name": "ImGuiCol_PlotLines",
+        "value": "42"
+      },
+      {
+        "calc_value": 43,
+        "name": "ImGuiCol_PlotLinesHovered",
+        "value": "43"
+      },
+      {
+        "calc_value": 44,
+        "name": "ImGuiCol_PlotHistogram",
+        "value": "44"
+      },
+      {
+        "calc_value": 45,
+        "name": "ImGuiCol_PlotHistogramHovered",
+        "value": "45"
+      },
+      {
+        "calc_value": 46,
+        "name": "ImGuiCol_TableHeaderBg",
+        "value": "46"
+      },
+      {
+        "calc_value": 47,
+        "name": "ImGuiCol_TableBorderStrong",
+        "value": "47"
+      },
+      {
+        "calc_value": 48,
+        "name": "ImGuiCol_TableBorderLight",
+        "value": "48"
+      },
+      {
+        "calc_value": 49,
+        "name": "ImGuiCol_TableRowBg",
+        "value": "49"
+      },
+      {
+        "calc_value": 50,
+        "name": "ImGuiCol_TableRowBgAlt",
+        "value": "50"
+      },
+      {
+        "calc_value": 51,
+        "name": "ImGuiCol_TextLink",
+        "value": "51"
+      },
+      {
+        "calc_value": 52,
+        "name": "ImGuiCol_TextSelectedBg",
+        "value": "52"
+      },
+      {
+        "calc_value": 53,
+        "name": "ImGuiCol_DragDropTarget",
+        "value": "53"
+      },
+      {
+        "calc_value": 54,
+        "name": "ImGuiCol_NavCursor",
+        "value": "54"
+      },
+      {
+        "calc_value": 55,
+        "name": "ImGuiCol_NavWindowingHighlight",
+        "value": "55"
+      },
+      {
+        "calc_value": 56,
+        "name": "ImGuiCol_NavWindowingDimBg",
+        "value": "56"
+      },
+      {
+        "calc_value": 57,
+        "name": "ImGuiCol_ModalWindowDimBg",
+        "value": "57"
+      },
+      {
+        "calc_value": 58,
+        "name": "ImGuiCol_COUNT",
+        "value": "58"
+      }
+    ],
+    "ImGuiColorEditFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiColorEditFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiColorEditFlags_NoAlpha",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiColorEditFlags_NoPicker",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiColorEditFlags_NoOptions",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiColorEditFlags_NoSmallPreview",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiColorEditFlags_NoInputs",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiColorEditFlags_NoTooltip",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiColorEditFlags_NoLabel",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiColorEditFlags_NoSidePreview",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiColorEditFlags_NoDragDrop",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiColorEditFlags_NoBorder",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiColorEditFlags_AlphaBar",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiColorEditFlags_AlphaPreview",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiColorEditFlags_AlphaPreviewHalf",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 524288,
+        "name": "ImGuiColorEditFlags_HDR",
+        "value": "1 << 19"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiColorEditFlags_DisplayRGB",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiColorEditFlags_DisplayHSV",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiColorEditFlags_DisplayHex",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 8388608,
+        "name": "ImGuiColorEditFlags_Uint8",
+        "value": "1 << 23"
+      },
+      {
+        "calc_value": 16777216,
+        "name": "ImGuiColorEditFlags_Float",
+        "value": "1 << 24"
+      },
+      {
+        "calc_value": 33554432,
+        "name": "ImGuiColorEditFlags_PickerHueBar",
+        "value": "1 << 25"
+      },
+      {
+        "calc_value": 67108864,
+        "name": "ImGuiColorEditFlags_PickerHueWheel",
+        "value": "1 << 26"
+      },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiColorEditFlags_InputRGB",
+        "value": "1 << 27"
+      },
+      {
+        "calc_value": 268435456,
+        "name": "ImGuiColorEditFlags_InputHSV",
+        "value": "1 << 28"
+      },
+      {
+        "calc_value": 177209344,
+        "name": "ImGuiColorEditFlags_DefaultOptions_",
+        "value": "ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_PickerHueBar"
+      },
+      {
+        "calc_value": 7340032,
+        "name": "ImGuiColorEditFlags_DisplayMask_",
+        "value": "ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_DisplayHex"
+      },
+      {
+        "calc_value": 25165824,
+        "name": "ImGuiColorEditFlags_DataTypeMask_",
+        "value": "ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_Float"
+      },
+      {
+        "calc_value": 100663296,
+        "name": "ImGuiColorEditFlags_PickerMask_",
+        "value": "ImGuiColorEditFlags_PickerHueWheel | ImGuiColorEditFlags_PickerHueBar"
+      },
+      {
+        "calc_value": 402653184,
+        "name": "ImGuiColorEditFlags_InputMask_",
+        "value": "ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_InputHSV"
+      }
+    ],
+    "ImGuiComboFlagsPrivate_": [
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiComboFlags_CustomPreview",
+        "value": "1 << 20"
+      }
+    ],
+    "ImGuiComboFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiComboFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiComboFlags_PopupAlignLeft",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiComboFlags_HeightSmall",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiComboFlags_HeightRegular",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiComboFlags_HeightLarge",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiComboFlags_HeightLargest",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiComboFlags_NoArrowButton",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiComboFlags_NoPreview",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiComboFlags_WidthFitPreview",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 30,
+        "name": "ImGuiComboFlags_HeightMask_",
+        "value": "ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest"
+      }
+    ],
+    "ImGuiCond_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiCond_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiCond_Always",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiCond_Once",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiCond_FirstUseEver",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiCond_Appearing",
+        "value": "1 << 3"
+      }
+    ],
+    "ImGuiConfigFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiConfigFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiConfigFlags_NavEnableKeyboard",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiConfigFlags_NavEnableGamepad",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiConfigFlags_NoMouse",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiConfigFlags_NoMouseCursorChange",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiConfigFlags_NoKeyboard",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiConfigFlags_DockingEnable",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiConfigFlags_ViewportsEnable",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiConfigFlags_DpiEnableScaleViewports",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiConfigFlags_DpiEnableScaleFonts",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiConfigFlags_IsSRGB",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiConfigFlags_IsTouchScreen",
+        "value": "1 << 21"
+      }
+    ],
+    "ImGuiContextHookType": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiContextHookType_NewFramePre",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiContextHookType_NewFramePost",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiContextHookType_EndFramePre",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiContextHookType_EndFramePost",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiContextHookType_RenderPre",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiContextHookType_RenderPost",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiContextHookType_Shutdown",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiContextHookType_PendingRemoval_",
+        "value": "7"
+      }
+    ],
+    "ImGuiDataAuthority_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiDataAuthority_Auto",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDataAuthority_DockNode",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiDataAuthority_Window",
+        "value": "2"
+      }
+    ],
+    "ImGuiDataTypePrivate_": [
+      {
+        "calc_value": 12,
+        "name": "ImGuiDataType_String",
+        "value": "ImGuiDataType_COUNT + 1"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImGuiDataType_Pointer",
+        "value": "ImGuiDataType_COUNT + 1+1"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImGuiDataType_ID",
+        "value": "ImGuiDataType_COUNT + 1+1+1"
+      }
+    ],
+    "ImGuiDataType_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiDataType_S8",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDataType_U8",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiDataType_S16",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiDataType_U16",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiDataType_S32",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiDataType_U32",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiDataType_S64",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiDataType_U64",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiDataType_Float",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiDataType_Double",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImGuiDataType_Bool",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImGuiDataType_COUNT",
+        "value": "11"
+      }
+    ],
+    "ImGuiDebugLogFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiDebugLogFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDebugLogFlags_EventError",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiDebugLogFlags_EventActiveId",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiDebugLogFlags_EventFocus",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiDebugLogFlags_EventPopup",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiDebugLogFlags_EventNav",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiDebugLogFlags_EventClipper",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiDebugLogFlags_EventSelection",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiDebugLogFlags_EventIO",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiDebugLogFlags_EventFont",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiDebugLogFlags_EventInputRouting",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiDebugLogFlags_EventDocking",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiDebugLogFlags_EventViewport",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4095,
+        "name": "ImGuiDebugLogFlags_EventMask_",
+        "value": "ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventFont | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiDebugLogFlags_OutputToTTY",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiDebugLogFlags_OutputToTestEngine",
+        "value": "1 << 21"
+      }
+    ],
+    "ImGuiDir": [
+      {
+        "calc_value": -1,
+        "name": "ImGuiDir_None",
+        "value": "-1"
+      },
+      {
+        "calc_value": 0,
+        "name": "ImGuiDir_Left",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDir_Right",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiDir_Up",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiDir_Down",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiDir_COUNT",
+        "value": "4"
+      }
+    ],
+    "ImGuiDockNodeFlagsPrivate_": [
+      {
+        "calc_value": 1024,
+        "name": "ImGuiDockNodeFlags_DockSpace",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiDockNodeFlags_CentralNode",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiDockNodeFlags_NoTabBar",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiDockNodeFlags_HiddenTabBar",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiDockNodeFlags_NoWindowMenuButton",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiDockNodeFlags_NoCloseButton",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiDockNodeFlags_NoResizeX",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiDockNodeFlags_NoResizeY",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiDockNodeFlags_DockedWindowsInFocusRoute",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 524288,
+        "name": "ImGuiDockNodeFlags_NoDockingSplitOther",
+        "value": "1 << 19"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiDockNodeFlags_NoDockingOverMe",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiDockNodeFlags_NoDockingOverOther",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiDockNodeFlags_NoDockingOverEmpty",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 7864336,
+        "name": "ImGuiDockNodeFlags_NoDocking",
+        "value": "ImGuiDockNodeFlags_NoDockingOverMe | ImGuiDockNodeFlags_NoDockingOverOther | ImGuiDockNodeFlags_NoDockingOverEmpty | ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoDockingSplitOther"
+      },
+      {
+        "calc_value": -1,
+        "name": "ImGuiDockNodeFlags_SharedFlagsInheritMask_",
+        "value": "~0"
+      },
+      {
+        "calc_value": 196640,
+        "name": "ImGuiDockNodeFlags_NoResizeFlagsMask_",
+        "value": "(int)ImGuiDockNodeFlags_NoResize | ImGuiDockNodeFlags_NoResizeX | ImGuiDockNodeFlags_NoResizeY"
+      },
+      {
+        "calc_value": 260208,
+        "name": "ImGuiDockNodeFlags_LocalFlagsTransferMask_",
+        "value": "(int)ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoResizeFlagsMask_ | (int)ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton"
+      },
+      {
+        "calc_value": 261152,
+        "name": "ImGuiDockNodeFlags_SavedFlagsMask_",
+        "value": "ImGuiDockNodeFlags_NoResizeFlagsMask_ | ImGuiDockNodeFlags_DockSpace | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton"
+      }
+    ],
+    "ImGuiDockNodeFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiDockNodeFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDockNodeFlags_KeepAliveOnly",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiDockNodeFlags_NoDockingOverCentralNode",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiDockNodeFlags_PassthruCentralNode",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiDockNodeFlags_NoDockingSplit",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiDockNodeFlags_NoResize",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiDockNodeFlags_AutoHideTabBar",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiDockNodeFlags_NoUndocking",
+        "value": "1 << 7"
+      }
+    ],
+    "ImGuiDockNodeState": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiDockNodeState_Unknown",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiDockNodeState_HostWindowHiddenBecauseWindowsAreResizing",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiDockNodeState_HostWindowVisible",
+        "value": "3"
+      }
+    ],
+    "ImGuiDragDropFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiDragDropFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiDragDropFlags_SourceNoPreviewTooltip",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiDragDropFlags_SourceNoDisableHover",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiDragDropFlags_SourceNoHoldToOpenOthers",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiDragDropFlags_SourceAllowNullID",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiDragDropFlags_SourceExtern",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiDragDropFlags_PayloadAutoExpire",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiDragDropFlags_PayloadNoCrossContext",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiDragDropFlags_PayloadNoCrossProcess",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiDragDropFlags_AcceptBeforeDelivery",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiDragDropFlags_AcceptNoDrawDefaultRect",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiDragDropFlags_AcceptNoPreviewTooltip",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 3072,
+        "name": "ImGuiDragDropFlags_AcceptPeekOnly",
+        "value": "ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect"
+      }
+    ],
+    "ImGuiFocusRequestFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiFocusRequestFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiFocusRequestFlags_RestoreFocusedChild",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiFocusRequestFlags_UnlessBelowModal",
+        "value": "1 << 1"
+      }
+    ],
+    "ImGuiFocusedFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiFocusedFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiFocusedFlags_ChildWindows",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiFocusedFlags_RootWindow",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiFocusedFlags_AnyWindow",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiFocusedFlags_NoPopupHierarchy",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiFocusedFlags_DockHierarchy",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiFocusedFlags_RootAndChildWindows",
+        "value": "ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows"
+      }
+    ],
+    "ImGuiFreeTypeBuilderFlags": [
+      {
+        "calc_value": 1,
+        "name": "ImGuiFreeTypeBuilderFlags_NoHinting",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiFreeTypeBuilderFlags_NoAutoHint",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiFreeTypeBuilderFlags_ForceAutoHint",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiFreeTypeBuilderFlags_LightHinting",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiFreeTypeBuilderFlags_MonoHinting",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiFreeTypeBuilderFlags_Bold",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiFreeTypeBuilderFlags_Oblique",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiFreeTypeBuilderFlags_Monochrome",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiFreeTypeBuilderFlags_LoadColor",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiFreeTypeBuilderFlags_Bitmap",
+        "value": "1 << 9"
+      }
+    ],
+    "ImGuiHoveredFlagsPrivate_": [
+      {
+        "calc_value": 245760,
+        "name": "ImGuiHoveredFlags_DelayMask_",
+        "value": "ImGuiHoveredFlags_DelayNone | ImGuiHoveredFlags_DelayShort | ImGuiHoveredFlags_DelayNormal | ImGuiHoveredFlags_NoSharedDelay"
+      },
+      {
+        "calc_value": 12479,
+        "name": "ImGuiHoveredFlags_AllowedMaskForIsWindowHovered",
+        "value": "ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_DockHierarchy | ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary"
+      },
+      {
+        "calc_value": 262048,
+        "name": "ImGuiHoveredFlags_AllowedMaskForIsItemHovered",
+        "value": "ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayMask_"
+      }
+    ],
+    "ImGuiHoveredFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiHoveredFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiHoveredFlags_ChildWindows",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiHoveredFlags_RootWindow",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiHoveredFlags_AnyWindow",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiHoveredFlags_NoPopupHierarchy",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiHoveredFlags_DockHierarchy",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiHoveredFlags_AllowWhenBlockedByPopup",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiHoveredFlags_AllowWhenBlockedByActiveItem",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiHoveredFlags_AllowWhenOverlappedByItem",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiHoveredFlags_AllowWhenOverlappedByWindow",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiHoveredFlags_AllowWhenDisabled",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiHoveredFlags_NoNavOverride",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 768,
+        "name": "ImGuiHoveredFlags_AllowWhenOverlapped",
+        "value": "ImGuiHoveredFlags_AllowWhenOverlappedByItem | ImGuiHoveredFlags_AllowWhenOverlappedByWindow"
+      },
+      {
+        "calc_value": 928,
+        "name": "ImGuiHoveredFlags_RectOnly",
+        "value": "ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiHoveredFlags_RootAndChildWindows",
+        "value": "ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiHoveredFlags_ForTooltip",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiHoveredFlags_Stationary",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiHoveredFlags_DelayNone",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiHoveredFlags_DelayShort",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiHoveredFlags_DelayNormal",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiHoveredFlags_NoSharedDelay",
+        "value": "1 << 17"
+      }
+    ],
+    "ImGuiInputEventType": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiInputEventType_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiInputEventType_MousePos",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiInputEventType_MouseWheel",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiInputEventType_MouseButton",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiInputEventType_MouseViewport",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiInputEventType_Key",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiInputEventType_Text",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiInputEventType_Focus",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiInputEventType_COUNT",
+        "value": "8"
+      }
+    ],
+    "ImGuiInputFlagsPrivate_": [
+      {
+        "calc_value": 2,
+        "name": "ImGuiInputFlags_RepeatRateDefault",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiInputFlags_RepeatRateNavMove",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiInputFlags_RepeatRateNavTweak",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiInputFlags_RepeatUntilRelease",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiInputFlags_RepeatUntilKeyModsChange",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiInputFlags_RepeatUntilOtherKeyPress",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiInputFlags_LockThisFrame",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiInputFlags_LockUntilRelease",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiInputFlags_CondHovered",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 8388608,
+        "name": "ImGuiInputFlags_CondActive",
+        "value": "1 << 23"
+      },
+      {
+        "calc_value": 12582912,
+        "name": "ImGuiInputFlags_CondDefault_",
+        "value": "ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImGuiInputFlags_RepeatRateMask_",
+        "value": "ImGuiInputFlags_RepeatRateDefault | ImGuiInputFlags_RepeatRateNavMove | ImGuiInputFlags_RepeatRateNavTweak"
+      },
+      {
+        "calc_value": 240,
+        "name": "ImGuiInputFlags_RepeatUntilMask_",
+        "value": "ImGuiInputFlags_RepeatUntilRelease | ImGuiInputFlags_RepeatUntilKeyModsChange | ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone | ImGuiInputFlags_RepeatUntilOtherKeyPress"
+      },
+      {
+        "calc_value": 255,
+        "name": "ImGuiInputFlags_RepeatMask_",
+        "value": "ImGuiInputFlags_Repeat | ImGuiInputFlags_RepeatRateMask_ | ImGuiInputFlags_RepeatUntilMask_"
+      },
+      {
+        "calc_value": 12582912,
+        "name": "ImGuiInputFlags_CondMask_",
+        "value": "ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive"
+      },
+      {
+        "calc_value": 15360,
+        "name": "ImGuiInputFlags_RouteTypeMask_",
+        "value": "ImGuiInputFlags_RouteActive | ImGuiInputFlags_RouteFocused | ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteAlways"
+      },
+      {
+        "calc_value": 245760,
+        "name": "ImGuiInputFlags_RouteOptionsMask_",
+        "value": "ImGuiInputFlags_RouteOverFocused | ImGuiInputFlags_RouteOverActive | ImGuiInputFlags_RouteUnlessBgFocused | ImGuiInputFlags_RouteFromRootWindow"
+      },
+      {
+        "calc_value": 255,
+        "name": "ImGuiInputFlags_SupportedByIsKeyPressed",
+        "value": "ImGuiInputFlags_RepeatMask_"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiInputFlags_SupportedByIsMouseClicked",
+        "value": "ImGuiInputFlags_Repeat"
+      },
+      {
+        "calc_value": 261375,
+        "name": "ImGuiInputFlags_SupportedByShortcut",
+        "value": "ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_"
+      },
+      {
+        "calc_value": 523519,
+        "name": "ImGuiInputFlags_SupportedBySetNextItemShortcut",
+        "value": "ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_ | ImGuiInputFlags_Tooltip"
+      },
+      {
+        "calc_value": 3145728,
+        "name": "ImGuiInputFlags_SupportedBySetKeyOwner",
+        "value": "ImGuiInputFlags_LockThisFrame | ImGuiInputFlags_LockUntilRelease"
+      },
+      {
+        "calc_value": 15728640,
+        "name": "ImGuiInputFlags_SupportedBySetItemKeyOwner",
+        "value": "ImGuiInputFlags_SupportedBySetKeyOwner | ImGuiInputFlags_CondMask_"
+      }
+    ],
+    "ImGuiInputFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiInputFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiInputFlags_Repeat",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiInputFlags_RouteActive",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiInputFlags_RouteFocused",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiInputFlags_RouteGlobal",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiInputFlags_RouteAlways",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiInputFlags_RouteOverFocused",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiInputFlags_RouteOverActive",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiInputFlags_RouteUnlessBgFocused",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiInputFlags_RouteFromRootWindow",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiInputFlags_Tooltip",
+        "value": "1 << 18"
+      }
+    ],
+    "ImGuiInputSource": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiInputSource_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiInputSource_Mouse",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiInputSource_Keyboard",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiInputSource_Gamepad",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiInputSource_COUNT",
+        "value": "4"
+      }
+    ],
+    "ImGuiInputTextFlagsPrivate_": [
+      {
+        "calc_value": 67108864,
+        "name": "ImGuiInputTextFlags_Multiline",
+        "value": "1 << 26"
+      },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiInputTextFlags_MergedItem",
+        "value": "1 << 27"
+      },
+      {
+        "calc_value": 268435456,
+        "name": "ImGuiInputTextFlags_LocalizeDecimalPoint",
+        "value": "1 << 28"
+      }
+    ],
+    "ImGuiInputTextFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiInputTextFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiInputTextFlags_CharsDecimal",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiInputTextFlags_CharsHexadecimal",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiInputTextFlags_CharsScientific",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiInputTextFlags_CharsUppercase",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiInputTextFlags_CharsNoBlank",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiInputTextFlags_AllowTabInput",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiInputTextFlags_EnterReturnsTrue",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiInputTextFlags_EscapeClearsAll",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiInputTextFlags_CtrlEnterForNewLine",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiInputTextFlags_ReadOnly",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiInputTextFlags_Password",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiInputTextFlags_AlwaysOverwrite",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiInputTextFlags_AutoSelectAll",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiInputTextFlags_ParseEmptyRefVal",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiInputTextFlags_DisplayEmptyRefVal",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiInputTextFlags_NoHorizontalScroll",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiInputTextFlags_NoUndoRedo",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiInputTextFlags_ElideLeft",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiInputTextFlags_CallbackCompletion",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 524288,
+        "name": "ImGuiInputTextFlags_CallbackHistory",
+        "value": "1 << 19"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiInputTextFlags_CallbackAlways",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiInputTextFlags_CallbackCharFilter",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiInputTextFlags_CallbackResize",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 8388608,
+        "name": "ImGuiInputTextFlags_CallbackEdit",
+        "value": "1 << 23"
+      }
+    ],
+    "ImGuiItemFlagsPrivate_": [
+      {
+        "calc_value": 1024,
+        "name": "ImGuiItemFlags_Disabled",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiItemFlags_ReadOnly",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiItemFlags_MixedValue",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiItemFlags_NoWindowHoverableCheck",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiItemFlags_AllowOverlap",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiItemFlags_NoNavDisableMouseHover",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiItemFlags_NoMarkEdited",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiItemFlags_Inputable",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiItemFlags_HasSelectionUserData",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiItemFlags_IsMultiSelect",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiItemFlags_Default_",
+        "value": "ImGuiItemFlags_AutoClosePopups"
+      }
+    ],
+    "ImGuiItemFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiItemFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiItemFlags_NoTabStop",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiItemFlags_NoNav",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiItemFlags_NoNavDefaultFocus",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiItemFlags_ButtonRepeat",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiItemFlags_AutoClosePopups",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiItemFlags_AllowDuplicateId",
+        "value": "1 << 5"
+      }
+    ],
+    "ImGuiItemStatusFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiItemStatusFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiItemStatusFlags_HoveredRect",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiItemStatusFlags_HasDisplayRect",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiItemStatusFlags_Edited",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiItemStatusFlags_ToggledSelection",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiItemStatusFlags_ToggledOpen",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiItemStatusFlags_HasDeactivated",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiItemStatusFlags_Deactivated",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiItemStatusFlags_HoveredWindow",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiItemStatusFlags_Visible",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiItemStatusFlags_HasClipRect",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiItemStatusFlags_HasShortcut",
+        "value": "1 << 10"
+      }
+    ],
+    "ImGuiKey": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiKey_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiKey_NamedKey_BEGIN",
+        "value": "512"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiKey_Tab",
+        "value": "512"
+      },
+      {
+        "calc_value": 513,
+        "name": "ImGuiKey_LeftArrow",
+        "value": "513"
+      },
+      {
+        "calc_value": 514,
+        "name": "ImGuiKey_RightArrow",
+        "value": "514"
+      },
+      {
+        "calc_value": 515,
+        "name": "ImGuiKey_UpArrow",
+        "value": "515"
+      },
+      {
+        "calc_value": 516,
+        "name": "ImGuiKey_DownArrow",
+        "value": "516"
+      },
+      {
+        "calc_value": 517,
+        "name": "ImGuiKey_PageUp",
+        "value": "517"
+      },
+      {
+        "calc_value": 518,
+        "name": "ImGuiKey_PageDown",
+        "value": "518"
+      },
+      {
+        "calc_value": 519,
+        "name": "ImGuiKey_Home",
+        "value": "519"
+      },
+      {
+        "calc_value": 520,
+        "name": "ImGuiKey_End",
+        "value": "520"
+      },
+      {
+        "calc_value": 521,
+        "name": "ImGuiKey_Insert",
+        "value": "521"
+      },
+      {
+        "calc_value": 522,
+        "name": "ImGuiKey_Delete",
+        "value": "522"
+      },
+      {
+        "calc_value": 523,
+        "name": "ImGuiKey_Backspace",
+        "value": "523"
+      },
+      {
+        "calc_value": 524,
+        "name": "ImGuiKey_Space",
+        "value": "524"
+      },
+      {
+        "calc_value": 525,
+        "name": "ImGuiKey_Enter",
+        "value": "525"
+      },
+      {
+        "calc_value": 526,
+        "name": "ImGuiKey_Escape",
+        "value": "526"
+      },
+      {
+        "calc_value": 527,
+        "name": "ImGuiKey_LeftCtrl",
+        "value": "527"
+      },
+      {
+        "calc_value": 528,
+        "name": "ImGuiKey_LeftShift",
+        "value": "528"
+      },
+      {
+        "calc_value": 529,
+        "name": "ImGuiKey_LeftAlt",
+        "value": "529"
+      },
+      {
+        "calc_value": 530,
+        "name": "ImGuiKey_LeftSuper",
+        "value": "530"
+      },
+      {
+        "calc_value": 531,
+        "name": "ImGuiKey_RightCtrl",
+        "value": "531"
+      },
+      {
+        "calc_value": 532,
+        "name": "ImGuiKey_RightShift",
+        "value": "532"
+      },
+      {
+        "calc_value": 533,
+        "name": "ImGuiKey_RightAlt",
+        "value": "533"
+      },
+      {
+        "calc_value": 534,
+        "name": "ImGuiKey_RightSuper",
+        "value": "534"
+      },
+      {
+        "calc_value": 535,
+        "name": "ImGuiKey_Menu",
+        "value": "535"
+      },
+      {
+        "calc_value": 536,
+        "name": "ImGuiKey_0",
+        "value": "536"
+      },
+      {
+        "calc_value": 537,
+        "name": "ImGuiKey_1",
+        "value": "537"
+      },
+      {
+        "calc_value": 538,
+        "name": "ImGuiKey_2",
+        "value": "538"
+      },
+      {
+        "calc_value": 539,
+        "name": "ImGuiKey_3",
+        "value": "539"
+      },
+      {
+        "calc_value": 540,
+        "name": "ImGuiKey_4",
+        "value": "540"
+      },
+      {
+        "calc_value": 541,
+        "name": "ImGuiKey_5",
+        "value": "541"
+      },
+      {
+        "calc_value": 542,
+        "name": "ImGuiKey_6",
+        "value": "542"
+      },
+      {
+        "calc_value": 543,
+        "name": "ImGuiKey_7",
+        "value": "543"
+      },
+      {
+        "calc_value": 544,
+        "name": "ImGuiKey_8",
+        "value": "544"
+      },
+      {
+        "calc_value": 545,
+        "name": "ImGuiKey_9",
+        "value": "545"
+      },
+      {
+        "calc_value": 546,
+        "name": "ImGuiKey_A",
+        "value": "546"
+      },
+      {
+        "calc_value": 547,
+        "name": "ImGuiKey_B",
+        "value": "547"
+      },
+      {
+        "calc_value": 548,
+        "name": "ImGuiKey_C",
+        "value": "548"
+      },
+      {
+        "calc_value": 549,
+        "name": "ImGuiKey_D",
+        "value": "549"
+      },
+      {
+        "calc_value": 550,
+        "name": "ImGuiKey_E",
+        "value": "550"
+      },
+      {
+        "calc_value": 551,
+        "name": "ImGuiKey_F",
+        "value": "551"
+      },
+      {
+        "calc_value": 552,
+        "name": "ImGuiKey_G",
+        "value": "552"
+      },
+      {
+        "calc_value": 553,
+        "name": "ImGuiKey_H",
+        "value": "553"
+      },
+      {
+        "calc_value": 554,
+        "name": "ImGuiKey_I",
+        "value": "554"
+      },
+      {
+        "calc_value": 555,
+        "name": "ImGuiKey_J",
+        "value": "555"
+      },
+      {
+        "calc_value": 556,
+        "name": "ImGuiKey_K",
+        "value": "556"
+      },
+      {
+        "calc_value": 557,
+        "name": "ImGuiKey_L",
+        "value": "557"
+      },
+      {
+        "calc_value": 558,
+        "name": "ImGuiKey_M",
+        "value": "558"
+      },
+      {
+        "calc_value": 559,
+        "name": "ImGuiKey_N",
+        "value": "559"
+      },
+      {
+        "calc_value": 560,
+        "name": "ImGuiKey_O",
+        "value": "560"
+      },
+      {
+        "calc_value": 561,
+        "name": "ImGuiKey_P",
+        "value": "561"
+      },
+      {
+        "calc_value": 562,
+        "name": "ImGuiKey_Q",
+        "value": "562"
+      },
+      {
+        "calc_value": 563,
+        "name": "ImGuiKey_R",
+        "value": "563"
+      },
+      {
+        "calc_value": 564,
+        "name": "ImGuiKey_S",
+        "value": "564"
+      },
+      {
+        "calc_value": 565,
+        "name": "ImGuiKey_T",
+        "value": "565"
+      },
+      {
+        "calc_value": 566,
+        "name": "ImGuiKey_U",
+        "value": "566"
+      },
+      {
+        "calc_value": 567,
+        "name": "ImGuiKey_V",
+        "value": "567"
+      },
+      {
+        "calc_value": 568,
+        "name": "ImGuiKey_W",
+        "value": "568"
+      },
+      {
+        "calc_value": 569,
+        "name": "ImGuiKey_X",
+        "value": "569"
+      },
+      {
+        "calc_value": 570,
+        "name": "ImGuiKey_Y",
+        "value": "570"
+      },
+      {
+        "calc_value": 571,
+        "name": "ImGuiKey_Z",
+        "value": "571"
+      },
+      {
+        "calc_value": 572,
+        "name": "ImGuiKey_F1",
+        "value": "572"
+      },
+      {
+        "calc_value": 573,
+        "name": "ImGuiKey_F2",
+        "value": "573"
+      },
+      {
+        "calc_value": 574,
+        "name": "ImGuiKey_F3",
+        "value": "574"
+      },
+      {
+        "calc_value": 575,
+        "name": "ImGuiKey_F4",
+        "value": "575"
+      },
+      {
+        "calc_value": 576,
+        "name": "ImGuiKey_F5",
+        "value": "576"
+      },
+      {
+        "calc_value": 577,
+        "name": "ImGuiKey_F6",
+        "value": "577"
+      },
+      {
+        "calc_value": 578,
+        "name": "ImGuiKey_F7",
+        "value": "578"
+      },
+      {
+        "calc_value": 579,
+        "name": "ImGuiKey_F8",
+        "value": "579"
+      },
+      {
+        "calc_value": 580,
+        "name": "ImGuiKey_F9",
+        "value": "580"
+      },
+      {
+        "calc_value": 581,
+        "name": "ImGuiKey_F10",
+        "value": "581"
+      },
+      {
+        "calc_value": 582,
+        "name": "ImGuiKey_F11",
+        "value": "582"
+      },
+      {
+        "calc_value": 583,
+        "name": "ImGuiKey_F12",
+        "value": "583"
+      },
+      {
+        "calc_value": 584,
+        "name": "ImGuiKey_F13",
+        "value": "584"
+      },
+      {
+        "calc_value": 585,
+        "name": "ImGuiKey_F14",
+        "value": "585"
+      },
+      {
+        "calc_value": 586,
+        "name": "ImGuiKey_F15",
+        "value": "586"
+      },
+      {
+        "calc_value": 587,
+        "name": "ImGuiKey_F16",
+        "value": "587"
+      },
+      {
+        "calc_value": 588,
+        "name": "ImGuiKey_F17",
+        "value": "588"
+      },
+      {
+        "calc_value": 589,
+        "name": "ImGuiKey_F18",
+        "value": "589"
+      },
+      {
+        "calc_value": 590,
+        "name": "ImGuiKey_F19",
+        "value": "590"
+      },
+      {
+        "calc_value": 591,
+        "name": "ImGuiKey_F20",
+        "value": "591"
+      },
+      {
+        "calc_value": 592,
+        "name": "ImGuiKey_F21",
+        "value": "592"
+      },
+      {
+        "calc_value": 593,
+        "name": "ImGuiKey_F22",
+        "value": "593"
+      },
+      {
+        "calc_value": 594,
+        "name": "ImGuiKey_F23",
+        "value": "594"
+      },
+      {
+        "calc_value": 595,
+        "name": "ImGuiKey_F24",
+        "value": "595"
+      },
+      {
+        "calc_value": 596,
+        "name": "ImGuiKey_Apostrophe",
+        "value": "596"
+      },
+      {
+        "calc_value": 597,
+        "name": "ImGuiKey_Comma",
+        "value": "597"
+      },
+      {
+        "calc_value": 598,
+        "name": "ImGuiKey_Minus",
+        "value": "598"
+      },
+      {
+        "calc_value": 599,
+        "name": "ImGuiKey_Period",
+        "value": "599"
+      },
+      {
+        "calc_value": 600,
+        "name": "ImGuiKey_Slash",
+        "value": "600"
+      },
+      {
+        "calc_value": 601,
+        "name": "ImGuiKey_Semicolon",
+        "value": "601"
+      },
+      {
+        "calc_value": 602,
+        "name": "ImGuiKey_Equal",
+        "value": "602"
+      },
+      {
+        "calc_value": 603,
+        "name": "ImGuiKey_LeftBracket",
+        "value": "603"
+      },
+      {
+        "calc_value": 604,
+        "name": "ImGuiKey_Backslash",
+        "value": "604"
+      },
+      {
+        "calc_value": 605,
+        "name": "ImGuiKey_RightBracket",
+        "value": "605"
+      },
+      {
+        "calc_value": 606,
+        "name": "ImGuiKey_GraveAccent",
+        "value": "606"
+      },
+      {
+        "calc_value": 607,
+        "name": "ImGuiKey_CapsLock",
+        "value": "607"
+      },
+      {
+        "calc_value": 608,
+        "name": "ImGuiKey_ScrollLock",
+        "value": "608"
+      },
+      {
+        "calc_value": 609,
+        "name": "ImGuiKey_NumLock",
+        "value": "609"
+      },
+      {
+        "calc_value": 610,
+        "name": "ImGuiKey_PrintScreen",
+        "value": "610"
+      },
+      {
+        "calc_value": 611,
+        "name": "ImGuiKey_Pause",
+        "value": "611"
+      },
+      {
+        "calc_value": 612,
+        "name": "ImGuiKey_Keypad0",
+        "value": "612"
+      },
+      {
+        "calc_value": 613,
+        "name": "ImGuiKey_Keypad1",
+        "value": "613"
+      },
+      {
+        "calc_value": 614,
+        "name": "ImGuiKey_Keypad2",
+        "value": "614"
+      },
+      {
+        "calc_value": 615,
+        "name": "ImGuiKey_Keypad3",
+        "value": "615"
+      },
+      {
+        "calc_value": 616,
+        "name": "ImGuiKey_Keypad4",
+        "value": "616"
+      },
+      {
+        "calc_value": 617,
+        "name": "ImGuiKey_Keypad5",
+        "value": "617"
+      },
+      {
+        "calc_value": 618,
+        "name": "ImGuiKey_Keypad6",
+        "value": "618"
+      },
+      {
+        "calc_value": 619,
+        "name": "ImGuiKey_Keypad7",
+        "value": "619"
+      },
+      {
+        "calc_value": 620,
+        "name": "ImGuiKey_Keypad8",
+        "value": "620"
+      },
+      {
+        "calc_value": 621,
+        "name": "ImGuiKey_Keypad9",
+        "value": "621"
+      },
+      {
+        "calc_value": 622,
+        "name": "ImGuiKey_KeypadDecimal",
+        "value": "622"
+      },
+      {
+        "calc_value": 623,
+        "name": "ImGuiKey_KeypadDivide",
+        "value": "623"
+      },
+      {
+        "calc_value": 624,
+        "name": "ImGuiKey_KeypadMultiply",
+        "value": "624"
+      },
+      {
+        "calc_value": 625,
+        "name": "ImGuiKey_KeypadSubtract",
+        "value": "625"
+      },
+      {
+        "calc_value": 626,
+        "name": "ImGuiKey_KeypadAdd",
+        "value": "626"
+      },
+      {
+        "calc_value": 627,
+        "name": "ImGuiKey_KeypadEnter",
+        "value": "627"
+      },
+      {
+        "calc_value": 628,
+        "name": "ImGuiKey_KeypadEqual",
+        "value": "628"
+      },
+      {
+        "calc_value": 629,
+        "name": "ImGuiKey_AppBack",
+        "value": "629"
+      },
+      {
+        "calc_value": 630,
+        "name": "ImGuiKey_AppForward",
+        "value": "630"
+      },
+      {
+        "calc_value": 631,
+        "name": "ImGuiKey_GamepadStart",
+        "value": "631"
+      },
+      {
+        "calc_value": 632,
+        "name": "ImGuiKey_GamepadBack",
+        "value": "632"
+      },
+      {
+        "calc_value": 633,
+        "name": "ImGuiKey_GamepadFaceLeft",
+        "value": "633"
+      },
+      {
+        "calc_value": 634,
+        "name": "ImGuiKey_GamepadFaceRight",
+        "value": "634"
+      },
+      {
+        "calc_value": 635,
+        "name": "ImGuiKey_GamepadFaceUp",
+        "value": "635"
+      },
+      {
+        "calc_value": 636,
+        "name": "ImGuiKey_GamepadFaceDown",
+        "value": "636"
+      },
+      {
+        "calc_value": 637,
+        "name": "ImGuiKey_GamepadDpadLeft",
+        "value": "637"
+      },
+      {
+        "calc_value": 638,
+        "name": "ImGuiKey_GamepadDpadRight",
+        "value": "638"
+      },
+      {
+        "calc_value": 639,
+        "name": "ImGuiKey_GamepadDpadUp",
+        "value": "639"
+      },
+      {
+        "calc_value": 640,
+        "name": "ImGuiKey_GamepadDpadDown",
+        "value": "640"
+      },
+      {
+        "calc_value": 641,
+        "name": "ImGuiKey_GamepadL1",
+        "value": "641"
+      },
+      {
+        "calc_value": 642,
+        "name": "ImGuiKey_GamepadR1",
+        "value": "642"
+      },
+      {
+        "calc_value": 643,
+        "name": "ImGuiKey_GamepadL2",
+        "value": "643"
+      },
+      {
+        "calc_value": 644,
+        "name": "ImGuiKey_GamepadR2",
+        "value": "644"
+      },
+      {
+        "calc_value": 645,
+        "name": "ImGuiKey_GamepadL3",
+        "value": "645"
+      },
+      {
+        "calc_value": 646,
+        "name": "ImGuiKey_GamepadR3",
+        "value": "646"
+      },
+      {
+        "calc_value": 647,
+        "name": "ImGuiKey_GamepadLStickLeft",
+        "value": "647"
+      },
+      {
+        "calc_value": 648,
+        "name": "ImGuiKey_GamepadLStickRight",
+        "value": "648"
+      },
+      {
+        "calc_value": 649,
+        "name": "ImGuiKey_GamepadLStickUp",
+        "value": "649"
+      },
+      {
+        "calc_value": 650,
+        "name": "ImGuiKey_GamepadLStickDown",
+        "value": "650"
+      },
+      {
+        "calc_value": 651,
+        "name": "ImGuiKey_GamepadRStickLeft",
+        "value": "651"
+      },
+      {
+        "calc_value": 652,
+        "name": "ImGuiKey_GamepadRStickRight",
+        "value": "652"
+      },
+      {
+        "calc_value": 653,
+        "name": "ImGuiKey_GamepadRStickUp",
+        "value": "653"
+      },
+      {
+        "calc_value": 654,
+        "name": "ImGuiKey_GamepadRStickDown",
+        "value": "654"
+      },
+      {
+        "calc_value": 655,
+        "name": "ImGuiKey_MouseLeft",
+        "value": "655"
+      },
+      {
+        "calc_value": 656,
+        "name": "ImGuiKey_MouseRight",
+        "value": "656"
+      },
+      {
+        "calc_value": 657,
+        "name": "ImGuiKey_MouseMiddle",
+        "value": "657"
+      },
+      {
+        "calc_value": 658,
+        "name": "ImGuiKey_MouseX1",
+        "value": "658"
+      },
+      {
+        "calc_value": 659,
+        "name": "ImGuiKey_MouseX2",
+        "value": "659"
+      },
+      {
+        "calc_value": 660,
+        "name": "ImGuiKey_MouseWheelX",
+        "value": "660"
+      },
+      {
+        "calc_value": 661,
+        "name": "ImGuiKey_MouseWheelY",
+        "value": "661"
+      },
+      {
+        "calc_value": 662,
+        "name": "ImGuiKey_ReservedForModCtrl",
+        "value": "662"
+      },
+      {
+        "calc_value": 663,
+        "name": "ImGuiKey_ReservedForModShift",
+        "value": "663"
+      },
+      {
+        "calc_value": 664,
+        "name": "ImGuiKey_ReservedForModAlt",
+        "value": "664"
+      },
+      {
+        "calc_value": 665,
+        "name": "ImGuiKey_ReservedForModSuper",
+        "value": "665"
+      },
+      {
+        "calc_value": 666,
+        "name": "ImGuiKey_NamedKey_END",
+        "value": "666"
+      },
+      {
+        "calc_value": 0,
+        "name": "ImGuiMod_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiMod_Ctrl",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiMod_Shift",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiMod_Alt",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiMod_Super",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 61440,
+        "name": "ImGuiMod_Mask_",
+        "value": "0xF000"
+      },
+      {
+        "calc_value": 154,
+        "name": "ImGuiKey_NamedKey_COUNT",
+        "value": "ImGuiKey_NamedKey_END - ImGuiKey_NamedKey_BEGIN"
+      }
+    ],
+    "ImGuiLayoutType_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiLayoutType_Horizontal",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiLayoutType_Vertical",
+        "value": "1"
+      }
+    ],
+    "ImGuiLocKey": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiLocKey_VersionStr",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiLocKey_TableSizeOne",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiLocKey_TableSizeAllFit",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiLocKey_TableSizeAllDefault",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiLocKey_TableResetOrder",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiLocKey_WindowingMainMenuBar",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiLocKey_WindowingPopup",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiLocKey_WindowingUntitled",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiLocKey_OpenLink_s",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiLocKey_CopyLink",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImGuiLocKey_DockingHideTabBar",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImGuiLocKey_DockingHoldShiftToDock",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ImGuiLocKey_DockingDragToUndockOrMoveNode",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImGuiLocKey_COUNT",
+        "value": "13"
+      }
+    ],
+    "ImGuiLogFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiLogFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiLogFlags_OutputTTY",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiLogFlags_OutputFile",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiLogFlags_OutputBuffer",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiLogFlags_OutputClipboard",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImGuiLogFlags_OutputMask_",
+        "value": "ImGuiLogFlags_OutputTTY | ImGuiLogFlags_OutputFile | ImGuiLogFlags_OutputBuffer | ImGuiLogFlags_OutputClipboard"
+      }
+    ],
+    "ImGuiMouseButton_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiMouseButton_Left",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiMouseButton_Right",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiMouseButton_Middle",
+        "value": "2"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiMouseButton_COUNT",
+        "value": "5"
+      }
+    ],
+    "ImGuiMouseCursor_": [
+      {
+        "calc_value": -1,
+        "name": "ImGuiMouseCursor_None",
+        "value": "-1"
+      },
+      {
+        "calc_value": 0,
+        "name": "ImGuiMouseCursor_Arrow",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiMouseCursor_TextInput",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiMouseCursor_ResizeAll",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiMouseCursor_ResizeNS",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiMouseCursor_ResizeEW",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiMouseCursor_ResizeNESW",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiMouseCursor_ResizeNWSE",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiMouseCursor_Hand",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiMouseCursor_NotAllowed",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiMouseCursor_COUNT",
+        "value": "9"
+      }
+    ],
+    "ImGuiMouseSource": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiMouseSource_Mouse",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiMouseSource_TouchScreen",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiMouseSource_Pen",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiMouseSource_COUNT",
+        "value": "3"
+      }
+    ],
+    "ImGuiMultiSelectFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiMultiSelectFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiMultiSelectFlags_SingleSelect",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiMultiSelectFlags_NoSelectAll",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiMultiSelectFlags_NoRangeSelect",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiMultiSelectFlags_NoAutoSelect",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiMultiSelectFlags_NoAutoClear",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiMultiSelectFlags_NoAutoClearOnReselect",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiMultiSelectFlags_BoxSelect1d",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiMultiSelectFlags_BoxSelect2d",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiMultiSelectFlags_BoxSelectNoScroll",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiMultiSelectFlags_ClearOnEscape",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiMultiSelectFlags_ClearOnClickVoid",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiMultiSelectFlags_ScopeWindow",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiMultiSelectFlags_ScopeRect",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiMultiSelectFlags_SelectOnClick",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiMultiSelectFlags_SelectOnClickRelease",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiMultiSelectFlags_NavWrapX",
+        "value": "1 << 16"
+      }
+    ],
+    "ImGuiNavLayer": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiNavLayer_Main",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiNavLayer_Menu",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiNavLayer_COUNT",
+        "value": "2"
+      }
+    ],
+    "ImGuiNavMoveFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiNavMoveFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiNavMoveFlags_LoopX",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiNavMoveFlags_LoopY",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiNavMoveFlags_WrapX",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiNavMoveFlags_WrapY",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImGuiNavMoveFlags_WrapMask_",
+        "value": "ImGuiNavMoveFlags_LoopX | ImGuiNavMoveFlags_LoopY | ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_WrapY"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiNavMoveFlags_AllowCurrentNavId",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiNavMoveFlags_AlsoScoreVisibleSet",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiNavMoveFlags_ScrollToEdgeY",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiNavMoveFlags_Forwarded",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiNavMoveFlags_DebugNoResult",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiNavMoveFlags_FocusApi",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiNavMoveFlags_IsTabbing",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiNavMoveFlags_IsPageMove",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiNavMoveFlags_Activate",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiNavMoveFlags_NoSelect",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiNavMoveFlags_NoSetNavCursorVisible",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiNavMoveFlags_NoClearActiveId",
+        "value": "1 << 15"
+      }
+    ],
+    "ImGuiNavRenderCursorFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiNavRenderCursorFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiNavRenderCursorFlags_Compact",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiNavRenderCursorFlags_AlwaysDraw",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiNavRenderCursorFlags_NoRounding",
+        "value": "1 << 3"
+      }
+    ],
+    "ImGuiNextItemDataFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiNextItemDataFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiNextItemDataFlags_HasWidth",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiNextItemDataFlags_HasOpen",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiNextItemDataFlags_HasShortcut",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiNextItemDataFlags_HasRefVal",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiNextItemDataFlags_HasStorageID",
+        "value": "1 << 4"
+      }
+    ],
+    "ImGuiNextWindowDataFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiNextWindowDataFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiNextWindowDataFlags_HasPos",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiNextWindowDataFlags_HasSize",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiNextWindowDataFlags_HasContentSize",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiNextWindowDataFlags_HasCollapsed",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiNextWindowDataFlags_HasSizeConstraint",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiNextWindowDataFlags_HasFocus",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiNextWindowDataFlags_HasBgAlpha",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiNextWindowDataFlags_HasScroll",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiNextWindowDataFlags_HasChildFlags",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiNextWindowDataFlags_HasRefreshPolicy",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiNextWindowDataFlags_HasViewport",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiNextWindowDataFlags_HasDock",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiNextWindowDataFlags_HasWindowClass",
+        "value": "1 << 12"
+      }
+    ],
+    "ImGuiOldColumnFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiOldColumnFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiOldColumnFlags_NoBorder",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiOldColumnFlags_NoResize",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiOldColumnFlags_NoPreserveWidths",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiOldColumnFlags_NoForceWithinWindow",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiOldColumnFlags_GrowParentContentsSize",
+        "value": "1 << 4"
+      }
+    ],
+    "ImGuiPlotType": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiPlotType_Lines",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiPlotType_Histogram",
+        "value": "1"
+      }
+    ],
+    "ImGuiPopupFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiPopupFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 0,
+        "name": "ImGuiPopupFlags_MouseButtonLeft",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiPopupFlags_MouseButtonRight",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiPopupFlags_MouseButtonMiddle",
+        "value": "2"
+      },
+      {
+        "calc_value": 31,
+        "name": "ImGuiPopupFlags_MouseButtonMask_",
+        "value": "0x1F"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiPopupFlags_MouseButtonDefault_",
+        "value": "1"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiPopupFlags_NoReopen",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiPopupFlags_NoOpenOverExistingPopup",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiPopupFlags_NoOpenOverItems",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiPopupFlags_AnyPopupId",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiPopupFlags_AnyPopupLevel",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 3072,
+        "name": "ImGuiPopupFlags_AnyPopup",
+        "value": "ImGuiPopupFlags_AnyPopupId | ImGuiPopupFlags_AnyPopupLevel"
+      }
+    ],
+    "ImGuiPopupPositionPolicy": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiPopupPositionPolicy_Default",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiPopupPositionPolicy_ComboBox",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiPopupPositionPolicy_Tooltip",
+        "value": "2"
+      }
+    ],
+    "ImGuiScrollFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiScrollFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiScrollFlags_KeepVisibleEdgeX",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiScrollFlags_KeepVisibleEdgeY",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiScrollFlags_KeepVisibleCenterX",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiScrollFlags_KeepVisibleCenterY",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiScrollFlags_AlwaysCenterX",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiScrollFlags_AlwaysCenterY",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiScrollFlags_NoScrollParent",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 21,
+        "name": "ImGuiScrollFlags_MaskX_",
+        "value": "ImGuiScrollFlags_KeepVisibleEdgeX | ImGuiScrollFlags_KeepVisibleCenterX | ImGuiScrollFlags_AlwaysCenterX"
+      },
+      {
+        "calc_value": 42,
+        "name": "ImGuiScrollFlags_MaskY_",
+        "value": "ImGuiScrollFlags_KeepVisibleEdgeY | ImGuiScrollFlags_KeepVisibleCenterY | ImGuiScrollFlags_AlwaysCenterY"
+      }
+    ],
+    "ImGuiSelectableFlagsPrivate_": [
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiSelectableFlags_NoHoldingActiveID",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiSelectableFlags_SelectOnNav",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiSelectableFlags_SelectOnClick",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 8388608,
+        "name": "ImGuiSelectableFlags_SelectOnRelease",
+        "value": "1 << 23"
+      },
+      {
+        "calc_value": 16777216,
+        "name": "ImGuiSelectableFlags_SpanAvailWidth",
+        "value": "1 << 24"
+      },
+      {
+        "calc_value": 33554432,
+        "name": "ImGuiSelectableFlags_SetNavIdOnHover",
+        "value": "1 << 25"
+      },
+      {
+        "calc_value": 67108864,
+        "name": "ImGuiSelectableFlags_NoPadWithHalfSpacing",
+        "value": "1 << 26"
+      },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiSelectableFlags_NoSetKeyOwner",
+        "value": "1 << 27"
+      }
+    ],
+    "ImGuiSelectableFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiSelectableFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiSelectableFlags_NoAutoClosePopups",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiSelectableFlags_SpanAllColumns",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiSelectableFlags_AllowDoubleClick",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiSelectableFlags_Disabled",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiSelectableFlags_AllowOverlap",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiSelectableFlags_Highlight",
+        "value": "1 << 5"
+      }
+    ],
+    "ImGuiSelectionRequestType": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiSelectionRequestType_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiSelectionRequestType_SetAll",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiSelectionRequestType_SetRange",
+        "value": "2"
+      }
+    ],
+    "ImGuiSeparatorFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiSeparatorFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiSeparatorFlags_Horizontal",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiSeparatorFlags_Vertical",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiSeparatorFlags_SpanAllColumns",
+        "value": "1 << 2"
+      }
+    ],
+    "ImGuiSliderFlagsPrivate_": [
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiSliderFlags_Vertical",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiSliderFlags_ReadOnly",
+        "value": "1 << 21"
+      }
+    ],
+    "ImGuiSliderFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiSliderFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiSliderFlags_Logarithmic",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiSliderFlags_NoRoundToFormat",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiSliderFlags_NoInput",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiSliderFlags_WrapAround",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiSliderFlags_ClampOnInput",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiSliderFlags_ClampZeroRange",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 1536,
+        "name": "ImGuiSliderFlags_AlwaysClamp",
+        "value": "ImGuiSliderFlags_ClampOnInput | ImGuiSliderFlags_ClampZeroRange"
+      },
+      {
+        "calc_value": 1879048207,
+        "name": "ImGuiSliderFlags_InvalidMask_",
+        "value": "0x7000000F"
+      }
+    ],
+    "ImGuiSortDirection": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiSortDirection_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiSortDirection_Ascending",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiSortDirection_Descending",
+        "value": "2"
+      }
+    ],
+    "ImGuiStyleVar_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiStyleVar_Alpha",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiStyleVar_DisabledAlpha",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiStyleVar_WindowPadding",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiStyleVar_WindowRounding",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiStyleVar_WindowBorderSize",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiStyleVar_WindowMinSize",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiStyleVar_WindowTitleAlign",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiStyleVar_ChildRounding",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiStyleVar_ChildBorderSize",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImGuiStyleVar_PopupRounding",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImGuiStyleVar_PopupBorderSize",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImGuiStyleVar_FramePadding",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ImGuiStyleVar_FrameRounding",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImGuiStyleVar_FrameBorderSize",
+        "value": "13"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImGuiStyleVar_ItemSpacing",
+        "value": "14"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImGuiStyleVar_ItemInnerSpacing",
+        "value": "15"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiStyleVar_IndentSpacing",
+        "value": "16"
+      },
+      {
+        "calc_value": 17,
+        "name": "ImGuiStyleVar_CellPadding",
+        "value": "17"
+      },
+      {
+        "calc_value": 18,
+        "name": "ImGuiStyleVar_ScrollbarSize",
+        "value": "18"
+      },
+      {
+        "calc_value": 19,
+        "name": "ImGuiStyleVar_ScrollbarRounding",
+        "value": "19"
+      },
+      {
+        "calc_value": 20,
+        "name": "ImGuiStyleVar_GrabMinSize",
+        "value": "20"
+      },
+      {
+        "calc_value": 21,
+        "name": "ImGuiStyleVar_GrabRounding",
+        "value": "21"
+      },
+      {
+        "calc_value": 22,
+        "name": "ImGuiStyleVar_TabRounding",
+        "value": "22"
+      },
+      {
+        "calc_value": 23,
+        "name": "ImGuiStyleVar_TabBorderSize",
+        "value": "23"
+      },
+      {
+        "calc_value": 24,
+        "name": "ImGuiStyleVar_TabBarBorderSize",
+        "value": "24"
+      },
+      {
+        "calc_value": 25,
+        "name": "ImGuiStyleVar_TabBarOverlineSize",
+        "value": "25"
+      },
+      {
+        "calc_value": 26,
+        "name": "ImGuiStyleVar_TableAngledHeadersAngle",
+        "value": "26"
+      },
+      {
+        "calc_value": 27,
+        "name": "ImGuiStyleVar_TableAngledHeadersTextAlign",
+        "value": "27"
+      },
+      {
+        "calc_value": 28,
+        "name": "ImGuiStyleVar_ButtonTextAlign",
+        "value": "28"
+      },
+      {
+        "calc_value": 29,
+        "name": "ImGuiStyleVar_SelectableTextAlign",
+        "value": "29"
+      },
+      {
+        "calc_value": 30,
+        "name": "ImGuiStyleVar_SeparatorTextBorderSize",
+        "value": "30"
+      },
+      {
+        "calc_value": 31,
+        "name": "ImGuiStyleVar_SeparatorTextAlign",
+        "value": "31"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiStyleVar_SeparatorTextPadding",
+        "value": "32"
+      },
+      {
+        "calc_value": 33,
+        "name": "ImGuiStyleVar_DockingSeparatorSize",
+        "value": "33"
+      },
+      {
+        "calc_value": 34,
+        "name": "ImGuiStyleVar_COUNT",
+        "value": "34"
+      }
+    ],
+    "ImGuiTabBarFlagsPrivate_": [
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiTabBarFlags_DockNode",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiTabBarFlags_IsFocused",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiTabBarFlags_SaveSettings",
+        "value": "1 << 22"
+      }
+    ],
+    "ImGuiTabBarFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTabBarFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTabBarFlags_Reorderable",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTabBarFlags_AutoSelectNewTabs",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiTabBarFlags_TabListPopupButton",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiTabBarFlags_NoCloseWithMiddleMouseButton",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiTabBarFlags_NoTabListScrollingButtons",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiTabBarFlags_NoTooltip",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiTabBarFlags_DrawSelectedOverline",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiTabBarFlags_FittingPolicyResizeDown",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiTabBarFlags_FittingPolicyScroll",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 384,
+        "name": "ImGuiTabBarFlags_FittingPolicyMask_",
+        "value": "ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiTabBarFlags_FittingPolicyDefault_",
+        "value": "ImGuiTabBarFlags_FittingPolicyResizeDown"
+      }
+    ],
+    "ImGuiTabItemFlagsPrivate_": [
+      {
+        "calc_value": 192,
+        "name": "ImGuiTabItemFlags_SectionMask_",
+        "value": "ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiTabItemFlags_NoCloseButton",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiTabItemFlags_Button",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiTabItemFlags_Unsorted",
+        "value": "1 << 22"
+      }
+    ],
+    "ImGuiTabItemFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTabItemFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTabItemFlags_UnsavedDocument",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTabItemFlags_SetSelected",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiTabItemFlags_NoCloseWithMiddleMouseButton",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiTabItemFlags_NoPushId",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiTabItemFlags_NoTooltip",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiTabItemFlags_NoReorder",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiTabItemFlags_Leading",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiTabItemFlags_Trailing",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiTabItemFlags_NoAssumedClosure",
+        "value": "1 << 8"
+      }
+    ],
+    "ImGuiTableBgTarget_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTableBgTarget_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTableBgTarget_RowBg0",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTableBgTarget_RowBg1",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiTableBgTarget_CellBg",
+        "value": "3"
+      }
+    ],
+    "ImGuiTableColumnFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTableColumnFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTableColumnFlags_Disabled",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTableColumnFlags_DefaultHide",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiTableColumnFlags_DefaultSort",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiTableColumnFlags_WidthStretch",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiTableColumnFlags_WidthFixed",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiTableColumnFlags_NoResize",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiTableColumnFlags_NoReorder",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiTableColumnFlags_NoHide",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiTableColumnFlags_NoClip",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiTableColumnFlags_NoSort",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiTableColumnFlags_NoSortAscending",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiTableColumnFlags_NoSortDescending",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiTableColumnFlags_NoHeaderLabel",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiTableColumnFlags_NoHeaderWidth",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiTableColumnFlags_PreferSortAscending",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiTableColumnFlags_PreferSortDescending",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiTableColumnFlags_IndentEnable",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiTableColumnFlags_IndentDisable",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiTableColumnFlags_AngledHeader",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 16777216,
+        "name": "ImGuiTableColumnFlags_IsEnabled",
+        "value": "1 << 24"
+      },
+      {
+        "calc_value": 33554432,
+        "name": "ImGuiTableColumnFlags_IsVisible",
+        "value": "1 << 25"
+      },
+      {
+        "calc_value": 67108864,
+        "name": "ImGuiTableColumnFlags_IsSorted",
+        "value": "1 << 26"
+      },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiTableColumnFlags_IsHovered",
+        "value": "1 << 27"
+      },
+      {
+        "calc_value": 24,
+        "name": "ImGuiTableColumnFlags_WidthMask_",
+        "value": "ImGuiTableColumnFlags_WidthStretch | ImGuiTableColumnFlags_WidthFixed"
+      },
+      {
+        "calc_value": 196608,
+        "name": "ImGuiTableColumnFlags_IndentMask_",
+        "value": "ImGuiTableColumnFlags_IndentEnable | ImGuiTableColumnFlags_IndentDisable"
+      },
+      {
+        "calc_value": 251658240,
+        "name": "ImGuiTableColumnFlags_StatusMask_",
+        "value": "ImGuiTableColumnFlags_IsEnabled | ImGuiTableColumnFlags_IsVisible | ImGuiTableColumnFlags_IsSorted | ImGuiTableColumnFlags_IsHovered"
+      },
+      {
+        "calc_value": 1073741824,
+        "name": "ImGuiTableColumnFlags_NoDirectResize_",
+        "value": "1 << 30"
+      }
+    ],
+    "ImGuiTableFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTableFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTableFlags_Resizable",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTableFlags_Reorderable",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiTableFlags_Hideable",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiTableFlags_Sortable",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiTableFlags_NoSavedSettings",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiTableFlags_ContextMenuInBody",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiTableFlags_RowBg",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiTableFlags_BordersInnerH",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiTableFlags_BordersOuterH",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiTableFlags_BordersInnerV",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiTableFlags_BordersOuterV",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 384,
+        "name": "ImGuiTableFlags_BordersH",
+        "value": "ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_BordersOuterH"
+      },
+      {
+        "calc_value": 1536,
+        "name": "ImGuiTableFlags_BordersV",
+        "value": "ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_BordersOuterV"
+      },
+      {
+        "calc_value": 640,
+        "name": "ImGuiTableFlags_BordersInner",
+        "value": "ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_BordersInnerH"
+      },
+      {
+        "calc_value": 1280,
+        "name": "ImGuiTableFlags_BordersOuter",
+        "value": "ImGuiTableFlags_BordersOuterV | ImGuiTableFlags_BordersOuterH"
+      },
+      {
+        "calc_value": 1920,
+        "name": "ImGuiTableFlags_Borders",
+        "value": "ImGuiTableFlags_BordersInner | ImGuiTableFlags_BordersOuter"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiTableFlags_NoBordersInBody",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiTableFlags_NoBordersInBodyUntilResize",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiTableFlags_SizingFixedFit",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiTableFlags_SizingFixedSame",
+        "value": "2 << 13"
+      },
+      {
+        "calc_value": 24576,
+        "name": "ImGuiTableFlags_SizingStretchProp",
+        "value": "3 << 13"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiTableFlags_SizingStretchSame",
+        "value": "4 << 13"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiTableFlags_NoHostExtendX",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiTableFlags_NoHostExtendY",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiTableFlags_NoKeepColumnsVisible",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 524288,
+        "name": "ImGuiTableFlags_PreciseWidths",
+        "value": "1 << 19"
+      },
+      {
+        "calc_value": 1048576,
+        "name": "ImGuiTableFlags_NoClip",
+        "value": "1 << 20"
+      },
+      {
+        "calc_value": 2097152,
+        "name": "ImGuiTableFlags_PadOuterX",
+        "value": "1 << 21"
+      },
+      {
+        "calc_value": 4194304,
+        "name": "ImGuiTableFlags_NoPadOuterX",
+        "value": "1 << 22"
+      },
+      {
+        "calc_value": 8388608,
+        "name": "ImGuiTableFlags_NoPadInnerX",
+        "value": "1 << 23"
+      },
+      {
+        "calc_value": 16777216,
+        "name": "ImGuiTableFlags_ScrollX",
+        "value": "1 << 24"
+      },
+      {
+        "calc_value": 33554432,
+        "name": "ImGuiTableFlags_ScrollY",
+        "value": "1 << 25"
+      },
+      {
+        "calc_value": 67108864,
+        "name": "ImGuiTableFlags_SortMulti",
+        "value": "1 << 26"
+      },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiTableFlags_SortTristate",
+        "value": "1 << 27"
+      },
+      {
+        "calc_value": 268435456,
+        "name": "ImGuiTableFlags_HighlightHoveredColumn",
+        "value": "1 << 28"
+      },
+      {
+        "calc_value": 57344,
+        "name": "ImGuiTableFlags_SizingMask_",
+        "value": "ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_SizingFixedSame | ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_SizingStretchSame"
+      }
+    ],
+    "ImGuiTableRowFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTableRowFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTableRowFlags_Headers",
+        "value": "1 << 0"
+      }
+    ],
+    "ImGuiTextFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTextFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTextFlags_NoWidthForLargeClippedText",
+        "value": "1 << 0"
+      }
+    ],
+    "ImGuiTooltipFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTooltipFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTooltipFlags_OverridePrevious",
+        "value": "1 << 1"
+      }
+    ],
+    "ImGuiTreeNodeFlagsPrivate_": [
+      {
+        "calc_value": 268435456,
+        "name": "ImGuiTreeNodeFlags_ClipLabelForTrailingButton",
+        "value": "1 << 28"
+      },
+      {
+        "calc_value": 536870912,
+        "name": "ImGuiTreeNodeFlags_UpsideDownArrow",
+        "value": "1 << 29"
+      },
+      {
+        "calc_value": 192,
+        "name": "ImGuiTreeNodeFlags_OpenOnMask_",
+        "value": "ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_OpenOnArrow"
+      }
+    ],
+    "ImGuiTreeNodeFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTreeNodeFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTreeNodeFlags_Selected",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTreeNodeFlags_Framed",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiTreeNodeFlags_AllowOverlap",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiTreeNodeFlags_NoTreePushOnOpen",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiTreeNodeFlags_NoAutoOpenOnLog",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiTreeNodeFlags_DefaultOpen",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiTreeNodeFlags_OpenOnDoubleClick",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiTreeNodeFlags_OpenOnArrow",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiTreeNodeFlags_Leaf",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiTreeNodeFlags_Bullet",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiTreeNodeFlags_FramePadding",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiTreeNodeFlags_SpanAvailWidth",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiTreeNodeFlags_SpanFullWidth",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiTreeNodeFlags_SpanTextWidth",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiTreeNodeFlags_SpanAllColumns",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiTreeNodeFlags_NavLeftJumpsBackHere",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 26,
+        "name": "ImGuiTreeNodeFlags_CollapsingHeader",
+        "value": "ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog"
+      }
+    ],
+    "ImGuiTypingSelectFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiTypingSelectFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiTypingSelectFlags_AllowBackspace",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiTypingSelectFlags_AllowSingleCharMode",
+        "value": "1 << 1"
+      }
+    ],
+    "ImGuiViewportFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiViewportFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiViewportFlags_IsPlatformWindow",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiViewportFlags_IsPlatformMonitor",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiViewportFlags_OwnedByApp",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiViewportFlags_NoDecoration",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiViewportFlags_NoTaskBarIcon",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiViewportFlags_NoFocusOnAppearing",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiViewportFlags_NoFocusOnClick",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiViewportFlags_NoInputs",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiViewportFlags_NoRendererClear",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiViewportFlags_NoAutoMerge",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiViewportFlags_TopMost",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiViewportFlags_CanHostOtherWindows",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiViewportFlags_IsMinimized",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiViewportFlags_IsFocused",
+        "value": "1 << 13"
+      }
+    ],
+    "ImGuiWindowDockStyleCol": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiWindowDockStyleCol_Text",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiWindowDockStyleCol_TabHovered",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiWindowDockStyleCol_TabFocused",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImGuiWindowDockStyleCol_TabSelected",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiWindowDockStyleCol_TabSelectedOverline",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImGuiWindowDockStyleCol_TabDimmed",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImGuiWindowDockStyleCol_TabDimmedSelected",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImGuiWindowDockStyleCol_TabDimmedSelectedOverline",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiWindowDockStyleCol_COUNT",
+        "value": "8"
+      }
+    ],
+    "ImGuiWindowFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiWindowFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiWindowFlags_NoTitleBar",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiWindowFlags_NoResize",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiWindowFlags_NoMove",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImGuiWindowFlags_NoScrollbar",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImGuiWindowFlags_NoScrollWithMouse",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImGuiWindowFlags_NoCollapse",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImGuiWindowFlags_AlwaysAutoResize",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImGuiWindowFlags_NoBackground",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImGuiWindowFlags_NoSavedSettings",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImGuiWindowFlags_NoMouseInputs",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImGuiWindowFlags_MenuBar",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImGuiWindowFlags_HorizontalScrollbar",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImGuiWindowFlags_NoFocusOnAppearing",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImGuiWindowFlags_NoBringToFrontOnFocus",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImGuiWindowFlags_AlwaysVerticalScrollbar",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImGuiWindowFlags_AlwaysHorizontalScrollbar",
+        "value": "1<< 15"
+      },
+      {
+        "calc_value": 65536,
+        "name": "ImGuiWindowFlags_NoNavInputs",
+        "value": "1 << 16"
+      },
+      {
+        "calc_value": 131072,
+        "name": "ImGuiWindowFlags_NoNavFocus",
+        "value": "1 << 17"
+      },
+      {
+        "calc_value": 262144,
+        "name": "ImGuiWindowFlags_UnsavedDocument",
+        "value": "1 << 18"
+      },
+      {
+        "calc_value": 524288,
+        "name": "ImGuiWindowFlags_NoDocking",
+        "value": "1 << 19"
+      },
+      {
+        "calc_value": 196608,
+        "name": "ImGuiWindowFlags_NoNav",
+        "value": "ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus"
+      },
+      {
+        "calc_value": 43,
+        "name": "ImGuiWindowFlags_NoDecoration",
+        "value": "ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse"
+      },
+      {
+        "calc_value": 197120,
+        "name": "ImGuiWindowFlags_NoInputs",
+        "value": "ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus"
+      },
+      {
+        "calc_value": 16777216,
+        "name": "ImGuiWindowFlags_ChildWindow",
+        "value": "1 << 24"
+      },
+      {
+        "calc_value": 33554432,
+        "name": "ImGuiWindowFlags_Tooltip",
+        "value": "1 << 25"
+      },
+      {
+        "calc_value": 67108864,
+        "name": "ImGuiWindowFlags_Popup",
+        "value": "1 << 26"
+      },
+      {
+        "calc_value": 134217728,
+        "name": "ImGuiWindowFlags_Modal",
+        "value": "1 << 27"
+      },
+      {
+        "calc_value": 268435456,
+        "name": "ImGuiWindowFlags_ChildMenu",
+        "value": "1 << 28"
+      },
+      {
+        "calc_value": 536870912,
+        "name": "ImGuiWindowFlags_DockNodeHost",
+        "value": "1 << 29"
+      }
+    ],
+    "ImGuiWindowRefreshFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImGuiWindowRefreshFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImGuiWindowRefreshFlags_TryToAvoidRefresh",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImGuiWindowRefreshFlags_RefreshOnHover",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImGuiWindowRefreshFlags_RefreshOnFocus",
+        "value": "1 << 2"
+      }
+    ]
+  },
+  "enumtypes": {
+    "ImGuiDir": "int",
+    "ImGuiKey": "int",
+    "ImGuiLocKey": "int",
+    "ImGuiMouseSource": "int",
+    "ImGuiSortDirection": "ImU8"
+  },
+  "locations": {
+    "ImBitVector": "imgui_internal:614",
+    "ImColor": "imgui:2862",
+    "ImDrawChannel": "imgui:3102",
+    "ImDrawCmd": "imgui:3059",
+    "ImDrawCmdHeader": "imgui:3094",
+    "ImDrawData": "imgui:3319",
+    "ImDrawDataBuilder": "imgui_internal:803",
+    "ImDrawFlags_": "imgui:3128",
+    "ImDrawList": "imgui:3166",
+    "ImDrawListFlags_": "imgui:3148",
+    "ImDrawListSharedData": "imgui_internal:781",
+    "ImDrawListSplitter": "imgui:3111",
+    "ImDrawVert": "imgui:3079",
+    "ImFont": "imgui:3545",
+    "ImFontAtlas": "imgui:3441",
+    "ImFontAtlasCustomRect": "imgui:3400",
+    "ImFontAtlasFlags_": "imgui:3416",
+    "ImFontBuilderIO": "imgui_internal:3839",
+    "ImFontConfig": "imgui:3343",
+    "ImFontGlyph": "imgui:3373",
+    "ImFontGlyphRangesBuilder": "imgui:3385",
+    "ImGuiActivateFlags_": "imgui_internal:1562",
+    "ImGuiAxis": "imgui_internal:1029",
+    "ImGuiBackendFlags_": "imgui:1667",
+    "ImGuiBoxSelectState": "imgui_internal:1751",
+    "ImGuiButtonFlagsPrivate_": "imgui_internal:919",
+    "ImGuiButtonFlags_": "imgui:1801",
+    "ImGuiChildFlags_": "imgui:1153",
+    "ImGuiCol_": "imgui:1682",
+    "ImGuiColorEditFlags_": "imgui:1812",
+    "ImGuiColorMod": "imgui_internal:1043",
+    "ImGuiComboFlagsPrivate_": "imgui_internal:944",
+    "ImGuiComboFlags_": "imgui:1299",
+    "ImGuiComboPreviewData": "imgui_internal:1060",
+    "ImGuiCond_": "imgui:1913",
+    "ImGuiConfigFlags_": "imgui:1638",
+    "ImGuiContext": "imgui_internal:2222",
+    "ImGuiContextHook": "imgui_internal:2207",
+    "ImGuiContextHookType": "imgui_internal:2205",
+    "ImGuiDataAuthority_": "imgui_internal:1864",
+    "ImGuiDataTypeInfo": "imgui_internal:829",
+    "ImGuiDataTypePrivate_": "imgui_internal:838",
+    "ImGuiDataTypeStorage": "imgui_internal:823",
+    "ImGuiDataType_": "imgui:1447",
+    "ImGuiDataVarInfo": "imgui_internal:815",
+    "ImGuiDebugAllocEntry": "imgui_internal:2141",
+    "ImGuiDebugAllocInfo": "imgui_internal:2148",
+    "ImGuiDebugLogFlags_": "imgui_internal:2119",
+    "ImGuiDir": "imgui:1464",
+    "ImGuiDockContext": "imgui_internal:1966",
+    "ImGuiDockNode": "imgui_internal:1880",
+    "ImGuiDockNodeFlagsPrivate_": "imgui_internal:1832",
+    "ImGuiDockNodeFlags_": "imgui:1400",
+    "ImGuiDockNodeState": "imgui_internal:1871",
+    "ImGuiDragDropFlags_": "imgui:1419",
+    "ImGuiErrorRecoveryState": "imgui_internal:1293",
+    "ImGuiFocusRequestFlags_": "imgui_internal:989",
+    "ImGuiFocusScopeData": "imgui_internal:1648",
+    "ImGuiFocusedFlags_": "imgui:1346",
+    "ImGuiFreeTypeBuilderFlags": "imgui_freetype:26",
+    "ImGuiGroupData": "imgui_internal:1073",
+    "ImGuiHoveredFlagsPrivate_": "imgui_internal:902",
+    "ImGuiHoveredFlags_": "imgui:1360",
+    "ImGuiIDStackTool": "imgui_internal:2188",
+    "ImGuiIO": "imgui:2286",
+    "ImGuiInputEvent": "imgui_internal:1422",
+    "ImGuiInputEventAppFocused": "imgui_internal:1420",
+    "ImGuiInputEventKey": "imgui_internal:1418",
+    "ImGuiInputEventMouseButton": "imgui_internal:1416",
+    "ImGuiInputEventMousePos": "imgui_internal:1414",
+    "ImGuiInputEventMouseViewport": "imgui_internal:1417",
+    "ImGuiInputEventMouseWheel": "imgui_internal:1415",
+    "ImGuiInputEventText": "imgui_internal:1419",
+    "ImGuiInputEventType": "imgui_internal:1390",
+    "ImGuiInputFlagsPrivate_": "imgui_internal:1489",
+    "ImGuiInputFlags_": "imgui:1615",
+    "ImGuiInputSource": "imgui_internal:1403",
+    "ImGuiInputTextCallbackData": "imgui:2540",
+    "ImGuiInputTextDeactivatedState": "imgui_internal:1109",
+    "ImGuiInputTextFlagsPrivate_": "imgui_internal:910",
+    "ImGuiInputTextFlags_": "imgui:1187",
+    "ImGuiInputTextState": "imgui_internal:1131",
+    "ImGuiItemFlagsPrivate_": "imgui_internal:852",
+    "ImGuiItemFlags_": "imgui:1174",
+    "ImGuiItemStatusFlags_": "imgui_internal:876",
+    "ImGuiKey": "imgui:1488",
+    "ImGuiKeyData": "imgui:2278",
+    "ImGuiKeyOwnerData": "imgui_internal:1476",
+    "ImGuiKeyRoutingData": "imgui_internal:1450",
+    "ImGuiKeyRoutingTable": "imgui_internal:1464",
+    "ImGuiLastItemData": "imgui_internal:1265",
+    "ImGuiLayoutType_": "imgui_internal:1010",
+    "ImGuiListClipper": "imgui:2769",
+    "ImGuiListClipperData": "imgui_internal:1546",
+    "ImGuiListClipperRange": "imgui_internal:1533",
+    "ImGuiLocEntry": "imgui_internal:2092",
+    "ImGuiLocKey": "imgui_internal:2074",
+    "ImGuiLogFlags_": "imgui_internal:1017",
+    "ImGuiMenuColumns": "imgui_internal:1091",
+    "ImGuiMetricsConfig": "imgui_internal:2158",
+    "ImGuiMouseButton_": "imgui:1873",
+    "ImGuiMouseCursor_": "imgui:1883",
+    "ImGuiMouseSource": "imgui:1902",
+    "ImGuiMultiSelectFlags_": "imgui:2920",
+    "ImGuiMultiSelectIO": "imgui:2947",
+    "ImGuiMultiSelectState": "imgui_internal:1808",
+    "ImGuiMultiSelectTempData": "imgui_internal:1783",
+    "ImGuiNavItemData": "imgui_internal:1631",
+    "ImGuiNavLayer": "imgui_internal:1623",
+    "ImGuiNavMoveFlags_": "imgui_internal:1601",
+    "ImGuiNavRenderCursorFlags_": "imgui_internal:1587",
+    "ImGuiNextItemData": "imgui_internal:1245",
+    "ImGuiNextItemDataFlags_": "imgui_internal:1235",
+    "ImGuiNextWindowData": "imgui_internal:1206",
+    "ImGuiNextWindowDataFlags_": "imgui_internal:1187",
+    "ImGuiOldColumnData": "imgui_internal:1716",
+    "ImGuiOldColumnFlags_": "imgui_internal:1696",
+    "ImGuiOldColumns": "imgui_internal:1726",
+    "ImGuiOnceUponAFrame": "imgui:2640",
+    "ImGuiPayload": "imgui:2605",
+    "ImGuiPlatformIO": "imgui:3717",
+    "ImGuiPlatformImeData": "imgui:3823",
+    "ImGuiPlatformMonitor": "imgui:3813",
+    "ImGuiPlotType": "imgui_internal:1036",
+    "ImGuiPopupData": "imgui_internal:1347",
+    "ImGuiPopupFlags_": "imgui:1264",
+    "ImGuiPopupPositionPolicy": "imgui_internal:1339",
+    "ImGuiPtrOrIndex": "imgui_internal:1326",
+    "ImGuiScrollFlags_": "imgui_internal:1573",
+    "ImGuiSelectableFlagsPrivate_": "imgui_internal:957",
+    "ImGuiSelectableFlags_": "imgui:1282",
+    "ImGuiSelectionBasicStorage": "imgui:2993",
+    "ImGuiSelectionExternalStorage": "imgui:3016",
+    "ImGuiSelectionRequest": "imgui:2967",
+    "ImGuiSelectionRequestType": "imgui:2959",
+    "ImGuiSeparatorFlags_": "imgui_internal:978",
+    "ImGuiSettingsHandler": "imgui_internal:2054",
+    "ImGuiShrinkWidthItem": "imgui_internal:1319",
+    "ImGuiSizeCallbackData": "imgui:2574",
+    "ImGuiSliderFlagsPrivate_": "imgui_internal:950",
+    "ImGuiSliderFlags_": "imgui:1858",
+    "ImGuiSortDirection": "imgui:1475",
+    "ImGuiStackLevelInfo": "imgui_internal:2176",
+    "ImGuiStorage": "imgui:2712",
+    "ImGuiStoragePair": "imgui:2695",
+    "ImGuiStyle": "imgui:2200",
+    "ImGuiStyleMod": "imgui_internal:1050",
+    "ImGuiStyleVar_": "imgui:1760",
+    "ImGuiTabBar": "imgui_internal:2852",
+    "ImGuiTabBarFlagsPrivate_": "imgui_internal:2815",
+    "ImGuiTabBarFlags_": "imgui:1314",
+    "ImGuiTabItem": "imgui_internal:2832",
+    "ImGuiTabItemFlagsPrivate_": "imgui_internal:2823",
+    "ImGuiTabItemFlags_": "imgui:1331",
+    "ImGuiTable": "imgui_internal:2999",
+    "ImGuiTableBgTarget_": "imgui:2054",
+    "ImGuiTableCellData": "imgui_internal:2967",
+    "ImGuiTableColumn": "imgui_internal:2907",
+    "ImGuiTableColumnFlags_": "imgui:2001",
+    "ImGuiTableColumnSettings": "imgui_internal:3146",
+    "ImGuiTableColumnSortSpecs": "imgui:2076",
+    "ImGuiTableFlags_": "imgui:1948",
+    "ImGuiTableHeaderData": "imgui_internal:2976",
+    "ImGuiTableInstanceData": "imgui_internal:2986",
+    "ImGuiTableRowFlags_": "imgui:2039",
+    "ImGuiTableSettings": "imgui_internal:3170",
+    "ImGuiTableSortSpecs": "imgui:2066",
+    "ImGuiTableTempData": "imgui_internal:3123",
+    "ImGuiTextBuffer": "imgui:2675",
+    "ImGuiTextFilter": "imgui:2648",
+    "ImGuiTextFlags_": "imgui_internal:996",
+    "ImGuiTextIndex": "imgui_internal:734",
+    "ImGuiTextRange": "imgui:2658",
+    "ImGuiTooltipFlags_": "imgui_internal:1002",
+    "ImGuiTreeNodeFlagsPrivate_": "imgui_internal:971",
+    "ImGuiTreeNodeFlags_": "imgui:1229",
+    "ImGuiTreeNodeStackData": "imgui_internal:1284",
+    "ImGuiTypingSelectFlags_": "imgui_internal:1659",
+    "ImGuiTypingSelectRequest": "imgui_internal:1667",
+    "ImGuiTypingSelectState": "imgui_internal:1678",
+    "ImGuiViewport": "imgui:3632",
+    "ImGuiViewportFlags_": "imgui:3604",
+    "ImGuiViewportP": "imgui_internal:1983",
+    "ImGuiWindow": "imgui_internal:2663",
+    "ImGuiWindowClass": "imgui:2589",
+    "ImGuiWindowDockStyle": "imgui_internal:1961",
+    "ImGuiWindowDockStyleCol": "imgui_internal:1947",
+    "ImGuiWindowFlags_": "imgui:1102",
+    "ImGuiWindowRefreshFlags_": "imgui_internal:1178",
+    "ImGuiWindowSettings": "imgui_internal:2035",
+    "ImGuiWindowStackData": "imgui_internal:1311",
+    "ImGuiWindowTempData": "imgui_internal:2613",
+    "ImRect": "imgui_internal:536",
+    "ImVec1": "imgui_internal:518",
+    "ImVec2": "imgui:296",
+    "ImVec2ih": "imgui_internal:526",
+    "ImVec4": "imgui:309"
+  },
+  "structs": {
+    "ImBitVector": [
+      {
+        "name": "Storage",
+        "template_type": "ImU32",
+        "type": "ImVector_ImU32"
+      }
+    ],
+    "ImColor": [
+      {
+        "name": "Value",
+        "type": "ImVec4"
+      }
+    ],
+    "ImDrawChannel": [
+      {
+        "name": "_CmdBuffer",
+        "template_type": "ImDrawCmd",
+        "type": "ImVector_ImDrawCmd"
+      },
+      {
+        "name": "_IdxBuffer",
+        "template_type": "ImDrawIdx",
+        "type": "ImVector_ImDrawIdx"
+      }
+    ],
+    "ImDrawCmd": [
+      {
+        "name": "ClipRect",
+        "type": "ImVec4"
+      },
+      {
+        "name": "TextureId",
+        "type": "ImTextureID"
+      },
+      {
+        "name": "VtxOffset",
+        "type": "unsigned int"
+      },
+      {
+        "name": "IdxOffset",
+        "type": "unsigned int"
+      },
+      {
+        "name": "ElemCount",
+        "type": "unsigned int"
+      },
+      {
+        "name": "UserCallback",
+        "type": "ImDrawCallback"
+      },
+      {
+        "name": "UserCallbackData",
+        "type": "void*"
+      },
+      {
+        "name": "UserCallbackDataSize",
+        "type": "int"
+      },
+      {
+        "name": "UserCallbackDataOffset",
+        "type": "int"
+      }
+    ],
+    "ImDrawCmdHeader": [
+      {
+        "name": "ClipRect",
+        "type": "ImVec4"
+      },
+      {
+        "name": "TextureId",
+        "type": "ImTextureID"
+      },
+      {
+        "name": "VtxOffset",
+        "type": "unsigned int"
+      }
+    ],
+    "ImDrawData": [
+      {
+        "name": "Valid",
+        "type": "bool"
+      },
+      {
+        "name": "CmdListsCount",
+        "type": "int"
+      },
+      {
+        "name": "TotalIdxCount",
+        "type": "int"
+      },
+      {
+        "name": "TotalVtxCount",
+        "type": "int"
+      },
+      {
+        "name": "CmdLists",
+        "template_type": "ImDrawList*",
+        "type": "ImVector_ImDrawListPtr"
+      },
+      {
+        "name": "DisplayPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DisplaySize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "FramebufferScale",
+        "type": "ImVec2"
+      },
+      {
+        "name": "OwnerViewport",
+        "type": "ImGuiViewport*"
+      }
+    ],
+    "ImDrawDataBuilder": [
+      {
+        "name": "Layers[2]",
+        "size": 2,
+        "template_type": "ImDrawList*",
+        "type": "ImVector_ImDrawListPtr*"
+      },
+      {
+        "name": "LayerData1",
+        "template_type": "ImDrawList*",
+        "type": "ImVector_ImDrawListPtr"
+      }
+    ],
+    "ImDrawList": [
+      {
+        "name": "CmdBuffer",
+        "template_type": "ImDrawCmd",
+        "type": "ImVector_ImDrawCmd"
+      },
+      {
+        "name": "IdxBuffer",
+        "template_type": "ImDrawIdx",
+        "type": "ImVector_ImDrawIdx"
+      },
+      {
+        "name": "VtxBuffer",
+        "template_type": "ImDrawVert",
+        "type": "ImVector_ImDrawVert"
+      },
+      {
+        "name": "Flags",
+        "type": "ImDrawListFlags"
+      },
+      {
+        "name": "_VtxCurrentIdx",
+        "type": "unsigned int"
+      },
+      {
+        "name": "_Data",
+        "type": "ImDrawListSharedData*"
+      },
+      {
+        "name": "_VtxWritePtr",
+        "type": "ImDrawVert*"
+      },
+      {
+        "name": "_IdxWritePtr",
+        "type": "ImDrawIdx*"
+      },
+      {
+        "name": "_Path",
+        "template_type": "ImVec2",
+        "type": "ImVector_ImVec2"
+      },
+      {
+        "name": "_CmdHeader",
+        "type": "ImDrawCmdHeader"
+      },
+      {
+        "name": "_Splitter",
+        "type": "ImDrawListSplitter"
+      },
+      {
+        "name": "_ClipRectStack",
+        "template_type": "ImVec4",
+        "type": "ImVector_ImVec4"
+      },
+      {
+        "name": "_TextureIdStack",
+        "template_type": "ImTextureID",
+        "type": "ImVector_ImTextureID"
+      },
+      {
+        "name": "_CallbacksDataBuf",
+        "template_type": "ImU8",
+        "type": "ImVector_ImU8"
+      },
+      {
+        "name": "_FringeScale",
+        "type": "float"
+      },
+      {
+        "name": "_OwnerName",
+        "type": "const char*"
+      }
+    ],
+    "ImDrawListSharedData": [
+      {
+        "name": "TexUvWhitePixel",
+        "type": "ImVec2"
+      },
+      {
+        "name": "TexUvLines",
+        "type": "const ImVec4*"
+      },
+      {
+        "name": "Font",
+        "type": "ImFont*"
+      },
+      {
+        "name": "FontSize",
+        "type": "float"
+      },
+      {
+        "name": "FontScale",
+        "type": "float"
+      },
+      {
+        "name": "CurveTessellationTol",
+        "type": "float"
+      },
+      {
+        "name": "CircleSegmentMaxError",
+        "type": "float"
+      },
+      {
+        "name": "ClipRectFullscreen",
+        "type": "ImVec4"
+      },
+      {
+        "name": "InitialFlags",
+        "type": "ImDrawListFlags"
+      },
+      {
+        "name": "TempBuffer",
+        "template_type": "ImVec2",
+        "type": "ImVector_ImVec2"
+      },
+      {
+        "name": "ArcFastVtx[48]",
+        "size": 48,
+        "type": "ImVec2"
+      },
+      {
+        "name": "ArcFastRadiusCutoff",
+        "type": "float"
+      },
+      {
+        "name": "CircleSegmentCounts[64]",
+        "size": 64,
+        "type": "ImU8"
+      }
+    ],
+    "ImDrawListSplitter": [
+      {
+        "name": "_Current",
+        "type": "int"
+      },
+      {
+        "name": "_Count",
+        "type": "int"
+      },
+      {
+        "name": "_Channels",
+        "template_type": "ImDrawChannel",
+        "type": "ImVector_ImDrawChannel"
+      }
+    ],
+    "ImDrawVert": [
+      {
+        "name": "pos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "uv",
+        "type": "ImVec2"
+      },
+      {
+        "name": "col",
+        "type": "ImU32"
+      }
+    ],
+    "ImFont": [
+      {
+        "name": "IndexAdvanceX",
+        "template_type": "float",
+        "type": "ImVector_float"
+      },
+      {
+        "name": "FallbackAdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "FontSize",
+        "type": "float"
+      },
+      {
+        "name": "IndexLookup",
+        "template_type": "ImWchar",
+        "type": "ImVector_ImWchar"
+      },
+      {
+        "name": "Glyphs",
+        "template_type": "ImFontGlyph",
+        "type": "ImVector_ImFontGlyph"
+      },
+      {
+        "name": "FallbackGlyph",
+        "type": "const ImFontGlyph*"
+      },
+      {
+        "name": "ContainerAtlas",
+        "type": "ImFontAtlas*"
+      },
+      {
+        "name": "ConfigData",
+        "type": "const ImFontConfig*"
+      },
+      {
+        "name": "ConfigDataCount",
+        "type": "short"
+      },
+      {
+        "name": "EllipsisCharCount",
+        "type": "short"
+      },
+      {
+        "name": "EllipsisChar",
+        "type": "ImWchar"
+      },
+      {
+        "name": "FallbackChar",
+        "type": "ImWchar"
+      },
+      {
+        "name": "EllipsisWidth",
+        "type": "float"
+      },
+      {
+        "name": "EllipsisCharStep",
+        "type": "float"
+      },
+      {
+        "name": "DirtyLookupTables",
+        "type": "bool"
+      },
+      {
+        "name": "Scale",
+        "type": "float"
+      },
+      {
+        "name": "Ascent",
+        "type": "float"
+      },
+      {
+        "name": "Descent",
+        "type": "float"
+      },
+      {
+        "name": "MetricsTotalSurface",
+        "type": "int"
+      },
+      {
+        "name": "Used4kPagesMap[(0xFFFF+1)/4096/8]",
+        "size": 2,
+        "type": "ImU8"
+      }
+    ],
+    "ImFontAtlas": [
+      {
+        "name": "Flags",
+        "type": "ImFontAtlasFlags"
+      },
+      {
+        "name": "TexID",
+        "type": "ImTextureID"
+      },
+      {
+        "name": "TexDesiredWidth",
+        "type": "int"
+      },
+      {
+        "name": "TexGlyphPadding",
+        "type": "int"
+      },
+      {
+        "name": "Locked",
+        "type": "bool"
+      },
+      {
+        "name": "UserData",
+        "type": "void*"
+      },
+      {
+        "name": "TexReady",
+        "type": "bool"
+      },
+      {
+        "name": "TexPixelsUseColors",
+        "type": "bool"
+      },
+      {
+        "name": "TexPixelsAlpha8",
+        "type": "unsigned char*"
+      },
+      {
+        "name": "TexPixelsRGBA32",
+        "type": "unsigned int*"
+      },
+      {
+        "name": "TexWidth",
+        "type": "int"
+      },
+      {
+        "name": "TexHeight",
+        "type": "int"
+      },
+      {
+        "name": "TexUvScale",
+        "type": "ImVec2"
+      },
+      {
+        "name": "TexUvWhitePixel",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Fonts",
+        "template_type": "ImFont*",
+        "type": "ImVector_ImFontPtr"
+      },
+      {
+        "name": "CustomRects",
+        "template_type": "ImFontAtlasCustomRect",
+        "type": "ImVector_ImFontAtlasCustomRect"
+      },
+      {
+        "name": "ConfigData",
+        "template_type": "ImFontConfig",
+        "type": "ImVector_ImFontConfig"
+      },
+      {
+        "name": "TexUvLines[(63)+1]",
+        "size": 64,
+        "type": "ImVec4"
+      },
+      {
+        "name": "FontBuilderIO",
+        "type": "const ImFontBuilderIO*"
+      },
+      {
+        "name": "FontBuilderFlags",
+        "type": "unsigned int"
+      },
+      {
+        "name": "PackIdMouseCursors",
+        "type": "int"
+      },
+      {
+        "name": "PackIdLines",
+        "type": "int"
+      }
+    ],
+    "ImFontAtlasCustomRect": [
+      {
+        "name": "X",
+        "type": "unsigned short"
+      },
+      {
+        "name": "Y",
+        "type": "unsigned short"
+      },
+      {
+        "name": "Width",
+        "type": "unsigned short"
+      },
+      {
+        "name": "Height",
+        "type": "unsigned short"
+      },
+      {
+        "bitfield": "31",
+        "name": "GlyphID",
+        "type": "unsigned int"
+      },
+      {
+        "bitfield": "1",
+        "name": "GlyphColored",
+        "type": "unsigned int"
+      },
+      {
+        "name": "GlyphAdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "GlyphOffset",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Font",
+        "type": "ImFont*"
+      }
+    ],
+    "ImFontBuilderIO": [
+      {
+        "name": "FontBuilder_Build",
+        "type": "bool(*)(ImFontAtlas* atlas)"
+      }
+    ],
+    "ImFontConfig": [
+      {
+        "name": "FontData",
+        "type": "void*"
+      },
+      {
+        "name": "FontDataSize",
+        "type": "int"
+      },
+      {
+        "name": "FontDataOwnedByAtlas",
+        "type": "bool"
+      },
+      {
+        "name": "FontNo",
+        "type": "int"
+      },
+      {
+        "name": "SizePixels",
+        "type": "float"
+      },
+      {
+        "name": "OversampleH",
+        "type": "int"
+      },
+      {
+        "name": "OversampleV",
+        "type": "int"
+      },
+      {
+        "name": "PixelSnapH",
+        "type": "bool"
+      },
+      {
+        "name": "GlyphExtraSpacing",
+        "type": "ImVec2"
+      },
+      {
+        "name": "GlyphOffset",
+        "type": "ImVec2"
+      },
+      {
+        "name": "GlyphRanges",
+        "type": "const ImWchar*"
+      },
+      {
+        "name": "GlyphMinAdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "GlyphMaxAdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "MergeMode",
+        "type": "bool"
+      },
+      {
+        "name": "FontBuilderFlags",
+        "type": "unsigned int"
+      },
+      {
+        "name": "RasterizerMultiply",
+        "type": "float"
+      },
+      {
+        "name": "RasterizerDensity",
+        "type": "float"
+      },
+      {
+        "name": "EllipsisChar",
+        "type": "ImWchar"
+      },
+      {
+        "name": "Name[40]",
+        "size": 40,
+        "type": "char"
+      },
+      {
+        "name": "DstFont",
+        "type": "ImFont*"
+      }
+    ],
+    "ImFontGlyph": [
+      {
+        "bitfield": "1",
+        "name": "Colored",
+        "type": "unsigned int"
+      },
+      {
+        "bitfield": "1",
+        "name": "Visible",
+        "type": "unsigned int"
+      },
+      {
+        "bitfield": "30",
+        "name": "Codepoint",
+        "type": "unsigned int"
+      },
+      {
+        "name": "AdvanceX",
+        "type": "float"
+      },
+      {
+        "name": "X0",
+        "type": "float"
+      },
+      {
+        "name": "Y0",
+        "type": "float"
+      },
+      {
+        "name": "X1",
+        "type": "float"
+      },
+      {
+        "name": "Y1",
+        "type": "float"
+      },
+      {
+        "name": "U0",
+        "type": "float"
+      },
+      {
+        "name": "V0",
+        "type": "float"
+      },
+      {
+        "name": "U1",
+        "type": "float"
+      },
+      {
+        "name": "V1",
+        "type": "float"
+      }
+    ],
+    "ImFontGlyphRangesBuilder": [
+      {
+        "name": "UsedChars",
+        "template_type": "ImU32",
+        "type": "ImVector_ImU32"
+      }
+    ],
+    "ImGuiBoxSelectState": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "IsActive",
+        "type": "bool"
+      },
+      {
+        "name": "IsStarting",
+        "type": "bool"
+      },
+      {
+        "name": "IsStartedFromVoid",
+        "type": "bool"
+      },
+      {
+        "name": "IsStartedSetNavIdOnce",
+        "type": "bool"
+      },
+      {
+        "name": "RequestClear",
+        "type": "bool"
+      },
+      {
+        "bitfield": "16",
+        "name": "KeyMods",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "StartPosRel",
+        "type": "ImVec2"
+      },
+      {
+        "name": "EndPosRel",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollAccum",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "UnclipMode",
+        "type": "bool"
+      },
+      {
+        "name": "UnclipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "BoxSelectRectPrev",
+        "type": "ImRect"
+      },
+      {
+        "name": "BoxSelectRectCurr",
+        "type": "ImRect"
+      }
+    ],
+    "ImGuiColorMod": [
+      {
+        "name": "Col",
+        "type": "ImGuiCol"
+      },
+      {
+        "name": "BackupValue",
+        "type": "ImVec4"
+      }
+    ],
+    "ImGuiComboPreviewData": [
+      {
+        "name": "PreviewRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "BackupCursorPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCursorMaxPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCursorPosPrevLine",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupPrevLineTextBaseOffset",
+        "type": "float"
+      },
+      {
+        "name": "BackupLayout",
+        "type": "ImGuiLayoutType"
+      }
+    ],
+    "ImGuiContext": [
+      {
+        "name": "Initialized",
+        "type": "bool"
+      },
+      {
+        "name": "FontAtlasOwnedByContext",
+        "type": "bool"
+      },
+      {
+        "name": "IO",
+        "type": "ImGuiIO"
+      },
+      {
+        "name": "PlatformIO",
+        "type": "ImGuiPlatformIO"
+      },
+      {
+        "name": "Style",
+        "type": "ImGuiStyle"
+      },
+      {
+        "name": "ConfigFlagsCurrFrame",
+        "type": "ImGuiConfigFlags"
+      },
+      {
+        "name": "ConfigFlagsLastFrame",
+        "type": "ImGuiConfigFlags"
+      },
+      {
+        "name": "Font",
+        "type": "ImFont*"
+      },
+      {
+        "name": "FontSize",
+        "type": "float"
+      },
+      {
+        "name": "FontBaseSize",
+        "type": "float"
+      },
+      {
+        "name": "FontScale",
+        "type": "float"
+      },
+      {
+        "name": "CurrentDpiScale",
+        "type": "float"
+      },
+      {
+        "name": "DrawListSharedData",
+        "type": "ImDrawListSharedData"
+      },
+      {
+        "name": "Time",
+        "type": "double"
+      },
+      {
+        "name": "FrameCount",
+        "type": "int"
+      },
+      {
+        "name": "FrameCountEnded",
+        "type": "int"
+      },
+      {
+        "name": "FrameCountPlatformEnded",
+        "type": "int"
+      },
+      {
+        "name": "FrameCountRendered",
+        "type": "int"
+      },
+      {
+        "name": "WithinFrameScope",
+        "type": "bool"
+      },
+      {
+        "name": "WithinFrameScopeWithImplicitWindow",
+        "type": "bool"
+      },
+      {
+        "name": "WithinEndChild",
+        "type": "bool"
+      },
+      {
+        "name": "GcCompactAll",
+        "type": "bool"
+      },
+      {
+        "name": "TestEngineHookItems",
+        "type": "bool"
+      },
+      {
+        "name": "TestEngine",
+        "type": "void*"
+      },
+      {
+        "name": "ContextName[16]",
+        "size": 16,
+        "type": "char"
+      },
+      {
+        "name": "InputEventsQueue",
+        "template_type": "ImGuiInputEvent",
+        "type": "ImVector_ImGuiInputEvent"
+      },
+      {
+        "name": "InputEventsTrail",
+        "template_type": "ImGuiInputEvent",
+        "type": "ImVector_ImGuiInputEvent"
+      },
+      {
+        "name": "InputEventsNextMouseSource",
+        "type": "ImGuiMouseSource"
+      },
+      {
+        "name": "InputEventsNextEventId",
+        "type": "ImU32"
+      },
+      {
+        "name": "Windows",
+        "template_type": "ImGuiWindow*",
+        "type": "ImVector_ImGuiWindowPtr"
+      },
+      {
+        "name": "WindowsFocusOrder",
+        "template_type": "ImGuiWindow*",
+        "type": "ImVector_ImGuiWindowPtr"
+      },
+      {
+        "name": "WindowsTempSortBuffer",
+        "template_type": "ImGuiWindow*",
+        "type": "ImVector_ImGuiWindowPtr"
+      },
+      {
+        "name": "CurrentWindowStack",
+        "template_type": "ImGuiWindowStackData",
+        "type": "ImVector_ImGuiWindowStackData"
+      },
+      {
+        "name": "WindowsById",
+        "type": "ImGuiStorage"
+      },
+      {
+        "name": "WindowsActiveCount",
+        "type": "int"
+      },
+      {
+        "name": "WindowsHoverPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DebugBreakInWindow",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "CurrentWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "HoveredWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "HoveredWindowUnderMovingWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "HoveredWindowBeforeClear",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "MovingWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "WheelingWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "WheelingWindowRefMousePos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WheelingWindowStartFrame",
+        "type": "int"
+      },
+      {
+        "name": "WheelingWindowScrolledFrame",
+        "type": "int"
+      },
+      {
+        "name": "WheelingWindowReleaseTimer",
+        "type": "float"
+      },
+      {
+        "name": "WheelingWindowWheelRemainder",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WheelingAxisAvg",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DebugDrawIdConflicts",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DebugHookIdInfo",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "HoveredId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "HoveredIdPreviousFrame",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "HoveredIdPreviousFrameItemCount",
+        "type": "int"
+      },
+      {
+        "name": "HoveredIdTimer",
+        "type": "float"
+      },
+      {
+        "name": "HoveredIdNotActiveTimer",
+        "type": "float"
+      },
+      {
+        "name": "HoveredIdAllowOverlap",
+        "type": "bool"
+      },
+      {
+        "name": "HoveredIdIsDisabled",
+        "type": "bool"
+      },
+      {
+        "name": "ItemUnclipByLog",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ActiveIdIsAlive",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ActiveIdTimer",
+        "type": "float"
+      },
+      {
+        "name": "ActiveIdIsJustActivated",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdAllowOverlap",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdNoClearOnFocusLoss",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdHasBeenPressedBefore",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdHasBeenEditedBefore",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdHasBeenEditedThisFrame",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdFromShortcut",
+        "type": "bool"
+      },
+      {
+        "bitfield": "8",
+        "name": "ActiveIdMouseButton",
+        "type": "int"
+      },
+      {
+        "name": "ActiveIdClickOffset",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ActiveIdWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ActiveIdSource",
+        "type": "ImGuiInputSource"
+      },
+      {
+        "name": "ActiveIdPreviousFrame",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ActiveIdPreviousFrameIsAlive",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdPreviousFrameHasBeenEditedBefore",
+        "type": "bool"
+      },
+      {
+        "name": "ActiveIdPreviousFrameWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "LastActiveId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LastActiveIdTimer",
+        "type": "float"
+      },
+      {
+        "name": "LastKeyModsChangeTime",
+        "type": "double"
+      },
+      {
+        "name": "LastKeyModsChangeFromNoneTime",
+        "type": "double"
+      },
+      {
+        "name": "LastKeyboardKeyPressTime",
+        "type": "double"
+      },
+      {
+        "name": "KeysMayBeCharInput",
+        "type": "ImBitArrayForNamedKeys"
+      },
+      {
+        "name": "KeysOwnerData[ImGuiKey_NamedKey_COUNT]",
+        "size": 154,
+        "type": "ImGuiKeyOwnerData"
+      },
+      {
+        "name": "KeysRoutingTable",
+        "type": "ImGuiKeyRoutingTable"
+      },
+      {
+        "name": "ActiveIdUsingNavDirMask",
+        "type": "ImU32"
+      },
+      {
+        "name": "ActiveIdUsingAllKeyboardKeys",
+        "type": "bool"
+      },
+      {
+        "name": "DebugBreakInShortcutRouting",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "CurrentFocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "CurrentItemFlags",
+        "type": "ImGuiItemFlags"
+      },
+      {
+        "name": "DebugLocateId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NextItemData",
+        "type": "ImGuiNextItemData"
+      },
+      {
+        "name": "LastItemData",
+        "type": "ImGuiLastItemData"
+      },
+      {
+        "name": "NextWindowData",
+        "type": "ImGuiNextWindowData"
+      },
+      {
+        "name": "DebugShowGroupRects",
+        "type": "bool"
+      },
+      {
+        "name": "DebugFlashStyleColorIdx",
+        "type": "ImGuiCol"
+      },
+      {
+        "name": "ColorStack",
+        "template_type": "ImGuiColorMod",
+        "type": "ImVector_ImGuiColorMod"
+      },
+      {
+        "name": "StyleVarStack",
+        "template_type": "ImGuiStyleMod",
+        "type": "ImVector_ImGuiStyleMod"
+      },
+      {
+        "name": "FontStack",
+        "template_type": "ImFont*",
+        "type": "ImVector_ImFontPtr"
+      },
+      {
+        "name": "FocusScopeStack",
+        "template_type": "ImGuiFocusScopeData",
+        "type": "ImVector_ImGuiFocusScopeData"
+      },
+      {
+        "name": "ItemFlagsStack",
+        "template_type": "ImGuiItemFlags",
+        "type": "ImVector_ImGuiItemFlags"
+      },
+      {
+        "name": "GroupStack",
+        "template_type": "ImGuiGroupData",
+        "type": "ImVector_ImGuiGroupData"
+      },
+      {
+        "name": "OpenPopupStack",
+        "template_type": "ImGuiPopupData",
+        "type": "ImVector_ImGuiPopupData"
+      },
+      {
+        "name": "BeginPopupStack",
+        "template_type": "ImGuiPopupData",
+        "type": "ImVector_ImGuiPopupData"
+      },
+      {
+        "name": "TreeNodeStack",
+        "template_type": "ImGuiTreeNodeStackData",
+        "type": "ImVector_ImGuiTreeNodeStackData"
+      },
+      {
+        "name": "Viewports",
+        "template_type": "ImGuiViewportP*",
+        "type": "ImVector_ImGuiViewportPPtr"
+      },
+      {
+        "name": "CurrentViewport",
+        "type": "ImGuiViewportP*"
+      },
+      {
+        "name": "MouseViewport",
+        "type": "ImGuiViewportP*"
+      },
+      {
+        "name": "MouseLastHoveredViewport",
+        "type": "ImGuiViewportP*"
+      },
+      {
+        "name": "PlatformLastFocusedViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "FallbackMonitor",
+        "type": "ImGuiPlatformMonitor"
+      },
+      {
+        "name": "PlatformMonitorsFullWorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "ViewportCreatedCount",
+        "type": "int"
+      },
+      {
+        "name": "PlatformWindowsCreatedCount",
+        "type": "int"
+      },
+      {
+        "name": "ViewportFocusedStampCount",
+        "type": "int"
+      },
+      {
+        "name": "NavCursorVisible",
+        "type": "bool"
+      },
+      {
+        "name": "NavHighlightItemUnderNav",
+        "type": "bool"
+      },
+      {
+        "name": "NavMousePosDirty",
+        "type": "bool"
+      },
+      {
+        "name": "NavIdIsAlive",
+        "type": "bool"
+      },
+      {
+        "name": "NavId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "NavFocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavLayer",
+        "type": "ImGuiNavLayer"
+      },
+      {
+        "name": "NavActivateId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavActivateDownId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavActivatePressedId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavActivateFlags",
+        "type": "ImGuiActivateFlags"
+      },
+      {
+        "name": "NavFocusRoute",
+        "template_type": "ImGuiFocusScopeData",
+        "type": "ImVector_ImGuiFocusScopeData"
+      },
+      {
+        "name": "NavHighlightActivatedId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavHighlightActivatedTimer",
+        "type": "float"
+      },
+      {
+        "name": "NavNextActivateId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavNextActivateFlags",
+        "type": "ImGuiActivateFlags"
+      },
+      {
+        "name": "NavInputSource",
+        "type": "ImGuiInputSource"
+      },
+      {
+        "name": "NavLastValidSelectionUserData",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "NavCursorHideFrames",
+        "type": "ImS8"
+      },
+      {
+        "name": "NavAnyRequest",
+        "type": "bool"
+      },
+      {
+        "name": "NavInitRequest",
+        "type": "bool"
+      },
+      {
+        "name": "NavInitRequestFromMove",
+        "type": "bool"
+      },
+      {
+        "name": "NavInitResult",
+        "type": "ImGuiNavItemData"
+      },
+      {
+        "name": "NavMoveSubmitted",
+        "type": "bool"
+      },
+      {
+        "name": "NavMoveScoringItems",
+        "type": "bool"
+      },
+      {
+        "name": "NavMoveForwardToNextFrame",
+        "type": "bool"
+      },
+      {
+        "name": "NavMoveFlags",
+        "type": "ImGuiNavMoveFlags"
+      },
+      {
+        "name": "NavMoveScrollFlags",
+        "type": "ImGuiScrollFlags"
+      },
+      {
+        "name": "NavMoveKeyMods",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "NavMoveDir",
+        "type": "ImGuiDir"
+      },
+      {
+        "name": "NavMoveDirForDebug",
+        "type": "ImGuiDir"
+      },
+      {
+        "name": "NavMoveClipDir",
+        "type": "ImGuiDir"
+      },
+      {
+        "name": "NavScoringRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "NavScoringNoClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "NavScoringDebugCount",
+        "type": "int"
+      },
+      {
+        "name": "NavTabbingDir",
+        "type": "int"
+      },
+      {
+        "name": "NavTabbingCounter",
+        "type": "int"
+      },
+      {
+        "name": "NavMoveResultLocal",
+        "type": "ImGuiNavItemData"
+      },
+      {
+        "name": "NavMoveResultLocalVisible",
+        "type": "ImGuiNavItemData"
+      },
+      {
+        "name": "NavMoveResultOther",
+        "type": "ImGuiNavItemData"
+      },
+      {
+        "name": "NavTabbingResultFirst",
+        "type": "ImGuiNavItemData"
+      },
+      {
+        "name": "NavJustMovedFromFocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavJustMovedToId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavJustMovedToFocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavJustMovedToKeyMods",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "NavJustMovedToIsTabbing",
+        "type": "bool"
+      },
+      {
+        "name": "NavJustMovedToHasSelectionData",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavWindowingKeyNext",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "ConfigNavWindowingKeyPrev",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "NavWindowingTarget",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "NavWindowingTargetAnim",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "NavWindowingListWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "NavWindowingTimer",
+        "type": "float"
+      },
+      {
+        "name": "NavWindowingHighlightAlpha",
+        "type": "float"
+      },
+      {
+        "name": "NavWindowingToggleLayer",
+        "type": "bool"
+      },
+      {
+        "name": "NavWindowingToggleKey",
+        "type": "ImGuiKey"
+      },
+      {
+        "name": "NavWindowingAccumDeltaPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "NavWindowingAccumDeltaSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DimBgRatio",
+        "type": "float"
+      },
+      {
+        "name": "DragDropActive",
+        "type": "bool"
+      },
+      {
+        "name": "DragDropWithinSource",
+        "type": "bool"
+      },
+      {
+        "name": "DragDropWithinTarget",
+        "type": "bool"
+      },
+      {
+        "name": "DragDropSourceFlags",
+        "type": "ImGuiDragDropFlags"
+      },
+      {
+        "name": "DragDropSourceFrameCount",
+        "type": "int"
+      },
+      {
+        "name": "DragDropMouseButton",
+        "type": "int"
+      },
+      {
+        "name": "DragDropPayload",
+        "type": "ImGuiPayload"
+      },
+      {
+        "name": "DragDropTargetRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "DragDropTargetClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "DragDropTargetId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DragDropAcceptFlags",
+        "type": "ImGuiDragDropFlags"
+      },
+      {
+        "name": "DragDropAcceptIdCurrRectSurface",
+        "type": "float"
+      },
+      {
+        "name": "DragDropAcceptIdCurr",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DragDropAcceptIdPrev",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DragDropAcceptFrameCount",
+        "type": "int"
+      },
+      {
+        "name": "DragDropHoldJustPressedId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DragDropPayloadBufHeap",
+        "template_type": "unsigned char",
+        "type": "ImVector_unsigned_char"
+      },
+      {
+        "name": "DragDropPayloadBufLocal[16]",
+        "size": 16,
+        "type": "unsigned char"
+      },
+      {
+        "name": "ClipperTempDataStacked",
+        "type": "int"
+      },
+      {
+        "name": "ClipperTempData",
+        "template_type": "ImGuiListClipperData",
+        "type": "ImVector_ImGuiListClipperData"
+      },
+      {
+        "name": "CurrentTable",
+        "type": "ImGuiTable*"
+      },
+      {
+        "name": "DebugBreakInTable",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "TablesTempDataStacked",
+        "type": "int"
+      },
+      {
+        "name": "TablesTempData",
+        "template_type": "ImGuiTableTempData",
+        "type": "ImVector_ImGuiTableTempData"
+      },
+      {
+        "name": "Tables",
+        "template_type": "ImGuiTable",
+        "type": "ImPool_ImGuiTable"
+      },
+      {
+        "name": "TablesLastTimeActive",
+        "template_type": "float",
+        "type": "ImVector_float"
+      },
+      {
+        "name": "DrawChannelsTempMergeBuffer",
+        "template_type": "ImDrawChannel",
+        "type": "ImVector_ImDrawChannel"
+      },
+      {
+        "name": "CurrentTabBar",
+        "type": "ImGuiTabBar*"
+      },
+      {
+        "name": "TabBars",
+        "template_type": "ImGuiTabBar",
+        "type": "ImPool_ImGuiTabBar"
+      },
+      {
+        "name": "CurrentTabBarStack",
+        "template_type": "ImGuiPtrOrIndex",
+        "type": "ImVector_ImGuiPtrOrIndex"
+      },
+      {
+        "name": "ShrinkWidthBuffer",
+        "template_type": "ImGuiShrinkWidthItem",
+        "type": "ImVector_ImGuiShrinkWidthItem"
+      },
+      {
+        "name": "BoxSelectState",
+        "type": "ImGuiBoxSelectState"
+      },
+      {
+        "name": "CurrentMultiSelect",
+        "type": "ImGuiMultiSelectTempData*"
+      },
+      {
+        "name": "MultiSelectTempDataStacked",
+        "type": "int"
+      },
+      {
+        "name": "MultiSelectTempData",
+        "template_type": "ImGuiMultiSelectTempData",
+        "type": "ImVector_ImGuiMultiSelectTempData"
+      },
+      {
+        "name": "MultiSelectStorage",
+        "template_type": "ImGuiMultiSelectState",
+        "type": "ImPool_ImGuiMultiSelectState"
+      },
+      {
+        "name": "HoverItemDelayId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "HoverItemDelayIdPreviousFrame",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "HoverItemDelayTimer",
+        "type": "float"
+      },
+      {
+        "name": "HoverItemDelayClearTimer",
+        "type": "float"
+      },
+      {
+        "name": "HoverItemUnlockedStationaryId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "HoverWindowUnlockedStationaryId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "MouseCursor",
+        "type": "ImGuiMouseCursor"
+      },
+      {
+        "name": "MouseStationaryTimer",
+        "type": "float"
+      },
+      {
+        "name": "MouseLastValidPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "InputTextState",
+        "type": "ImGuiInputTextState"
+      },
+      {
+        "name": "InputTextDeactivatedState",
+        "type": "ImGuiInputTextDeactivatedState"
+      },
+      {
+        "name": "InputTextPasswordFont",
+        "type": "ImFont"
+      },
+      {
+        "name": "TempInputId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DataTypeZeroValue",
+        "type": "ImGuiDataTypeStorage"
+      },
+      {
+        "name": "BeginMenuDepth",
+        "type": "int"
+      },
+      {
+        "name": "BeginComboDepth",
+        "type": "int"
+      },
+      {
+        "name": "ColorEditOptions",
+        "type": "ImGuiColorEditFlags"
+      },
+      {
+        "name": "ColorEditCurrentID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ColorEditSavedID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ColorEditSavedHue",
+        "type": "float"
+      },
+      {
+        "name": "ColorEditSavedSat",
+        "type": "float"
+      },
+      {
+        "name": "ColorEditSavedColor",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorPickerRef",
+        "type": "ImVec4"
+      },
+      {
+        "name": "ComboPreviewData",
+        "type": "ImGuiComboPreviewData"
+      },
+      {
+        "name": "WindowResizeBorderExpectedRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "WindowResizeRelativeMode",
+        "type": "bool"
+      },
+      {
+        "name": "ScrollbarSeekMode",
+        "type": "short"
+      },
+      {
+        "name": "ScrollbarClickDeltaToGrabCenter",
+        "type": "float"
+      },
+      {
+        "name": "SliderGrabClickOffset",
+        "type": "float"
+      },
+      {
+        "name": "SliderCurrentAccum",
+        "type": "float"
+      },
+      {
+        "name": "SliderCurrentAccumDirty",
+        "type": "bool"
+      },
+      {
+        "name": "DragCurrentAccumDirty",
+        "type": "bool"
+      },
+      {
+        "name": "DragCurrentAccum",
+        "type": "float"
+      },
+      {
+        "name": "DragSpeedDefaultRatio",
+        "type": "float"
+      },
+      {
+        "name": "DisabledAlphaBackup",
+        "type": "float"
+      },
+      {
+        "name": "DisabledStackSize",
+        "type": "short"
+      },
+      {
+        "name": "TooltipOverrideCount",
+        "type": "short"
+      },
+      {
+        "name": "TooltipPreviousWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ClipboardHandlerData",
+        "template_type": "char",
+        "type": "ImVector_char"
+      },
+      {
+        "name": "MenusIdSubmittedThisFrame",
+        "template_type": "ImGuiID",
+        "type": "ImVector_ImGuiID"
+      },
+      {
+        "name": "TypingSelectState",
+        "type": "ImGuiTypingSelectState"
+      },
+      {
+        "name": "PlatformImeData",
+        "type": "ImGuiPlatformImeData"
+      },
+      {
+        "name": "PlatformImeDataPrev",
+        "type": "ImGuiPlatformImeData"
+      },
+      {
+        "name": "PlatformImeViewport",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DockContext",
+        "type": "ImGuiDockContext"
+      },
+      {
+        "name": "DockNodeWindowMenuHandler",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiDockNode* node,ImGuiTabBar* tab_bar)"
+      },
+      {
+        "name": "SettingsLoaded",
+        "type": "bool"
+      },
+      {
+        "name": "SettingsDirtyTimer",
+        "type": "float"
+      },
+      {
+        "name": "SettingsIniData",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "SettingsHandlers",
+        "template_type": "ImGuiSettingsHandler",
+        "type": "ImVector_ImGuiSettingsHandler"
+      },
+      {
+        "name": "SettingsWindows",
+        "template_type": "ImGuiWindowSettings",
+        "type": "ImChunkStream_ImGuiWindowSettings"
+      },
+      {
+        "name": "SettingsTables",
+        "template_type": "ImGuiTableSettings",
+        "type": "ImChunkStream_ImGuiTableSettings"
+      },
+      {
+        "name": "Hooks",
+        "template_type": "ImGuiContextHook",
+        "type": "ImVector_ImGuiContextHook"
+      },
+      {
+        "name": "HookIdNext",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LocalizationTable[ImGuiLocKey_COUNT]",
+        "size": 13,
+        "type": "const char*"
+      },
+      {
+        "name": "LogEnabled",
+        "type": "bool"
+      },
+      {
+        "name": "LogFlags",
+        "type": "ImGuiLogFlags"
+      },
+      {
+        "name": "LogWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "LogFile",
+        "type": "ImFileHandle"
+      },
+      {
+        "name": "LogBuffer",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "LogNextPrefix",
+        "type": "const char*"
+      },
+      {
+        "name": "LogNextSuffix",
+        "type": "const char*"
+      },
+      {
+        "name": "LogLinePosY",
+        "type": "float"
+      },
+      {
+        "name": "LogLineFirstItem",
+        "type": "bool"
+      },
+      {
+        "name": "LogDepthRef",
+        "type": "int"
+      },
+      {
+        "name": "LogDepthToExpand",
+        "type": "int"
+      },
+      {
+        "name": "LogDepthToExpandDefault",
+        "type": "int"
+      },
+      {
+        "name": "ErrorCallback",
+        "type": "ImGuiErrorCallback"
+      },
+      {
+        "name": "ErrorCallbackUserData",
+        "type": "void*"
+      },
+      {
+        "name": "ErrorTooltipLockedPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ErrorFirst",
+        "type": "bool"
+      },
+      {
+        "name": "ErrorCountCurrentFrame",
+        "type": "int"
+      },
+      {
+        "name": "StackSizesInNewFrame",
+        "type": "ImGuiErrorRecoveryState"
+      },
+      {
+        "name": "StackSizesInBeginForCurrentWindow",
+        "type": "ImGuiErrorRecoveryState*"
+      },
+      {
+        "name": "DebugDrawIdConflictsCount",
+        "type": "int"
+      },
+      {
+        "name": "DebugLogFlags",
+        "type": "ImGuiDebugLogFlags"
+      },
+      {
+        "name": "DebugLogBuf",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "DebugLogIndex",
+        "type": "ImGuiTextIndex"
+      },
+      {
+        "name": "DebugLogSkippedErrors",
+        "type": "int"
+      },
+      {
+        "name": "DebugLogAutoDisableFlags",
+        "type": "ImGuiDebugLogFlags"
+      },
+      {
+        "name": "DebugLogAutoDisableFrames",
+        "type": "ImU8"
+      },
+      {
+        "name": "DebugLocateFrames",
+        "type": "ImU8"
+      },
+      {
+        "name": "DebugBreakInLocateId",
+        "type": "bool"
+      },
+      {
+        "name": "DebugBreakKeyChord",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "DebugBeginReturnValueCullDepth",
+        "type": "ImS8"
+      },
+      {
+        "name": "DebugItemPickerActive",
+        "type": "bool"
+      },
+      {
+        "name": "DebugItemPickerMouseButton",
+        "type": "ImU8"
+      },
+      {
+        "name": "DebugItemPickerBreakId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DebugFlashStyleColorTime",
+        "type": "float"
+      },
+      {
+        "name": "DebugFlashStyleColorBackup",
+        "type": "ImVec4"
+      },
+      {
+        "name": "DebugMetricsConfig",
+        "type": "ImGuiMetricsConfig"
+      },
+      {
+        "name": "DebugIDStackTool",
+        "type": "ImGuiIDStackTool"
+      },
+      {
+        "name": "DebugAllocInfo",
+        "type": "ImGuiDebugAllocInfo"
+      },
+      {
+        "name": "DebugHoveredDockNode",
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "FramerateSecPerFrame[60]",
+        "size": 60,
+        "type": "float"
+      },
+      {
+        "name": "FramerateSecPerFrameIdx",
+        "type": "int"
+      },
+      {
+        "name": "FramerateSecPerFrameCount",
+        "type": "int"
+      },
+      {
+        "name": "FramerateSecPerFrameAccum",
+        "type": "float"
+      },
+      {
+        "name": "WantCaptureMouseNextFrame",
+        "type": "int"
+      },
+      {
+        "name": "WantCaptureKeyboardNextFrame",
+        "type": "int"
+      },
+      {
+        "name": "WantTextInputNextFrame",
+        "type": "int"
+      },
+      {
+        "name": "TempBuffer",
+        "template_type": "char",
+        "type": "ImVector_char"
+      },
+      {
+        "name": "TempKeychordName[64]",
+        "size": 64,
+        "type": "char"
+      }
+    ],
+    "ImGuiContextHook": [
+      {
+        "name": "HookId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Type",
+        "type": "ImGuiContextHookType"
+      },
+      {
+        "name": "Owner",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Callback",
+        "type": "ImGuiContextHookCallback"
+      },
+      {
+        "name": "UserData",
+        "type": "void*"
+      }
+    ],
+    "ImGuiDataTypeInfo": [
+      {
+        "name": "Size",
+        "type": "size_t"
+      },
+      {
+        "name": "Name",
+        "type": "const char*"
+      },
+      {
+        "name": "PrintFmt",
+        "type": "const char*"
+      },
+      {
+        "name": "ScanFmt",
+        "type": "const char*"
+      }
+    ],
+    "ImGuiDataTypeStorage": [
+      {
+        "name": "Data[8]",
+        "size": 8,
+        "type": "ImU8"
+      }
+    ],
+    "ImGuiDataVarInfo": [
+      {
+        "name": "Type",
+        "type": "ImGuiDataType"
+      },
+      {
+        "name": "Count",
+        "type": "ImU32"
+      },
+      {
+        "name": "Offset",
+        "type": "ImU32"
+      }
+    ],
+    "ImGuiDebugAllocEntry": [
+      {
+        "name": "FrameCount",
+        "type": "int"
+      },
+      {
+        "name": "AllocCount",
+        "type": "ImS16"
+      },
+      {
+        "name": "FreeCount",
+        "type": "ImS16"
+      }
+    ],
+    "ImGuiDebugAllocInfo": [
+      {
+        "name": "TotalAllocCount",
+        "type": "int"
+      },
+      {
+        "name": "TotalFreeCount",
+        "type": "int"
+      },
+      {
+        "name": "LastEntriesIdx",
+        "type": "ImS16"
+      },
+      {
+        "name": "LastEntriesBuf[6]",
+        "size": 6,
+        "type": "ImGuiDebugAllocEntry"
+      }
+    ],
+    "ImGuiDockContext": [
+      {
+        "name": "Nodes",
+        "type": "ImGuiStorage"
+      },
+      {
+        "name": "Requests",
+        "template_type": "ImGuiDockRequest",
+        "type": "ImVector_ImGuiDockRequest"
+      },
+      {
+        "name": "NodesSettings",
+        "template_type": "ImGuiDockNodeSettings",
+        "type": "ImVector_ImGuiDockNodeSettings"
+      },
+      {
+        "name": "WantFullRebuild",
+        "type": "bool"
+      }
+    ],
+    "ImGuiDockNode": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "SharedFlags",
+        "type": "ImGuiDockNodeFlags"
+      },
+      {
+        "name": "LocalFlags",
+        "type": "ImGuiDockNodeFlags"
+      },
+      {
+        "name": "LocalFlagsInWindows",
+        "type": "ImGuiDockNodeFlags"
+      },
+      {
+        "name": "MergedFlags",
+        "type": "ImGuiDockNodeFlags"
+      },
+      {
+        "name": "State",
+        "type": "ImGuiDockNodeState"
+      },
+      {
+        "name": "ParentNode",
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "ChildNodes[2]",
+        "size": 2,
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "Windows",
+        "template_type": "ImGuiWindow*",
+        "type": "ImVector_ImGuiWindowPtr"
+      },
+      {
+        "name": "TabBar",
+        "type": "ImGuiTabBar*"
+      },
+      {
+        "name": "Pos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Size",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SizeRef",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SplitAxis",
+        "type": "ImGuiAxis"
+      },
+      {
+        "name": "WindowClass",
+        "type": "ImGuiWindowClass"
+      },
+      {
+        "name": "LastBgColor",
+        "type": "ImU32"
+      },
+      {
+        "name": "HostWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "VisibleWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "CentralNode",
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "OnlyNodeWithWindows",
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "CountNodeWithWindows",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameAlive",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameActive",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameFocused",
+        "type": "int"
+      },
+      {
+        "name": "LastFocusedNodeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "SelectedTabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "WantCloseTabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "RefViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "bitfield": "3",
+        "name": "AuthorityForPos",
+        "type": "ImGuiDataAuthority"
+      },
+      {
+        "bitfield": "3",
+        "name": "AuthorityForSize",
+        "type": "ImGuiDataAuthority"
+      },
+      {
+        "bitfield": "3",
+        "name": "AuthorityForViewport",
+        "type": "ImGuiDataAuthority"
+      },
+      {
+        "bitfield": "1",
+        "name": "IsVisible",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "IsFocused",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "IsBgDrawnThisFrame",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "HasCloseButton",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "HasWindowMenuButton",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "HasCentralNodeChild",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "WantCloseAll",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "WantLockSizeOnce",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "WantMouseMove",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "WantHiddenTabBarUpdate",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "WantHiddenTabBarToggle",
+        "type": "bool"
+      }
+    ],
+    "ImGuiErrorRecoveryState": [
+      {
+        "name": "SizeOfWindowStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfIDStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfTreeStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfColorStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfStyleVarStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfFontStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfFocusScopeStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfGroupStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfItemFlagsStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfBeginPopupStack",
+        "type": "short"
+      },
+      {
+        "name": "SizeOfDisabledStack",
+        "type": "short"
+      }
+    ],
+    "ImGuiFocusScopeData": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "WindowID",
+        "type": "ImGuiID"
+      }
+    ],
+    "ImGuiGroupData": [
+      {
+        "name": "WindowID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "BackupCursorPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCursorMaxPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCursorPosPrevLine",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupIndent",
+        "type": "ImVec1"
+      },
+      {
+        "name": "BackupGroupOffset",
+        "type": "ImVec1"
+      },
+      {
+        "name": "BackupCurrLineSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCurrLineTextBaseOffset",
+        "type": "float"
+      },
+      {
+        "name": "BackupActiveIdIsAlive",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "BackupActiveIdPreviousFrameIsAlive",
+        "type": "bool"
+      },
+      {
+        "name": "BackupHoveredIdIsAlive",
+        "type": "bool"
+      },
+      {
+        "name": "BackupIsSameLine",
+        "type": "bool"
+      },
+      {
+        "name": "EmitItem",
+        "type": "bool"
+      }
+    ],
+    "ImGuiIDStackTool": [
+      {
+        "name": "LastActiveFrame",
+        "type": "int"
+      },
+      {
+        "name": "StackLevel",
+        "type": "int"
+      },
+      {
+        "name": "QueryId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Results",
+        "template_type": "ImGuiStackLevelInfo",
+        "type": "ImVector_ImGuiStackLevelInfo"
+      },
+      {
+        "name": "CopyToClipboardOnCtrlC",
+        "type": "bool"
+      },
+      {
+        "name": "CopyToClipboardLastTime",
+        "type": "float"
+      }
+    ],
+    "ImGuiIO": [
+      {
+        "name": "ConfigFlags",
+        "type": "ImGuiConfigFlags"
+      },
+      {
+        "name": "BackendFlags",
+        "type": "ImGuiBackendFlags"
+      },
+      {
+        "name": "DisplaySize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DeltaTime",
+        "type": "float"
+      },
+      {
+        "name": "IniSavingRate",
+        "type": "float"
+      },
+      {
+        "name": "IniFilename",
+        "type": "const char*"
+      },
+      {
+        "name": "LogFilename",
+        "type": "const char*"
+      },
+      {
+        "name": "UserData",
+        "type": "void*"
+      },
+      {
+        "name": "Fonts",
+        "type": "ImFontAtlas*"
+      },
+      {
+        "name": "FontGlobalScale",
+        "type": "float"
+      },
+      {
+        "name": "FontAllowUserScaling",
+        "type": "bool"
+      },
+      {
+        "name": "FontDefault",
+        "type": "ImFont*"
+      },
+      {
+        "name": "DisplayFramebufferScale",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ConfigNavSwapGamepadButtons",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavMoveSetMousePos",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavCaptureKeyboard",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavEscapeClearFocusItem",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavEscapeClearFocusWindow",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavCursorVisibleAuto",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigNavCursorVisibleAlways",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDockingNoSplit",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDockingWithShift",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDockingAlwaysTabBar",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDockingTransparentPayload",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigViewportsNoAutoMerge",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigViewportsNoTaskBarIcon",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigViewportsNoDecoration",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigViewportsNoDefaultParent",
+        "type": "bool"
+      },
+      {
+        "name": "MouseDrawCursor",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigMacOSXBehaviors",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigInputTrickleEventQueue",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigInputTextCursorBlink",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigInputTextEnterKeepActive",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDragClickToInputText",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigWindowsResizeFromEdges",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigWindowsMoveFromTitleBarOnly",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigWindowsCopyContentsWithCtrlC",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigScrollbarScrollByPage",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigMemoryCompactTimer",
+        "type": "float"
+      },
+      {
+        "name": "MouseDoubleClickTime",
+        "type": "float"
+      },
+      {
+        "name": "MouseDoubleClickMaxDist",
+        "type": "float"
+      },
+      {
+        "name": "MouseDragThreshold",
+        "type": "float"
+      },
+      {
+        "name": "KeyRepeatDelay",
+        "type": "float"
+      },
+      {
+        "name": "KeyRepeatRate",
+        "type": "float"
+      },
+      {
+        "name": "ConfigErrorRecovery",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigErrorRecoveryEnableAssert",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigErrorRecoveryEnableDebugLog",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigErrorRecoveryEnableTooltip",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDebugIsDebuggerPresent",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDebugHighlightIdConflicts",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDebugBeginReturnValueOnce",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDebugBeginReturnValueLoop",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDebugIgnoreFocusLoss",
+        "type": "bool"
+      },
+      {
+        "name": "ConfigDebugIniSettings",
+        "type": "bool"
+      },
+      {
+        "name": "BackendPlatformName",
+        "type": "const char*"
+      },
+      {
+        "name": "BackendRendererName",
+        "type": "const char*"
+      },
+      {
+        "name": "BackendPlatformUserData",
+        "type": "void*"
+      },
+      {
+        "name": "BackendRendererUserData",
+        "type": "void*"
+      },
+      {
+        "name": "BackendLanguageUserData",
+        "type": "void*"
+      },
+      {
+        "name": "WantCaptureMouse",
+        "type": "bool"
+      },
+      {
+        "name": "WantCaptureKeyboard",
+        "type": "bool"
+      },
+      {
+        "name": "WantTextInput",
+        "type": "bool"
+      },
+      {
+        "name": "WantSetMousePos",
+        "type": "bool"
+      },
+      {
+        "name": "WantSaveIniSettings",
+        "type": "bool"
+      },
+      {
+        "name": "NavActive",
+        "type": "bool"
+      },
+      {
+        "name": "NavVisible",
+        "type": "bool"
+      },
+      {
+        "name": "Framerate",
+        "type": "float"
+      },
+      {
+        "name": "MetricsRenderVertices",
+        "type": "int"
+      },
+      {
+        "name": "MetricsRenderIndices",
+        "type": "int"
+      },
+      {
+        "name": "MetricsRenderWindows",
+        "type": "int"
+      },
+      {
+        "name": "MetricsActiveWindows",
+        "type": "int"
+      },
+      {
+        "name": "MouseDelta",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Ctx",
+        "type": "ImGuiContext*"
+      },
+      {
+        "name": "MousePos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MouseDown[5]",
+        "size": 5,
+        "type": "bool"
+      },
+      {
+        "name": "MouseWheel",
+        "type": "float"
+      },
+      {
+        "name": "MouseWheelH",
+        "type": "float"
+      },
+      {
+        "name": "MouseSource",
+        "type": "ImGuiMouseSource"
+      },
+      {
+        "name": "MouseHoveredViewport",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "KeyCtrl",
+        "type": "bool"
+      },
+      {
+        "name": "KeyShift",
+        "type": "bool"
+      },
+      {
+        "name": "KeyAlt",
+        "type": "bool"
+      },
+      {
+        "name": "KeySuper",
+        "type": "bool"
+      },
+      {
+        "name": "KeyMods",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "KeysData[ImGuiKey_NamedKey_COUNT]",
+        "size": 154,
+        "type": "ImGuiKeyData"
+      },
+      {
+        "name": "WantCaptureMouseUnlessPopupClose",
+        "type": "bool"
+      },
+      {
+        "name": "MousePosPrev",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MouseClickedPos[5]",
+        "size": 5,
+        "type": "ImVec2"
+      },
+      {
+        "name": "MouseClickedTime[5]",
+        "size": 5,
+        "type": "double"
+      },
+      {
+        "name": "MouseClicked[5]",
+        "size": 5,
+        "type": "bool"
+      },
+      {
+        "name": "MouseDoubleClicked[5]",
+        "size": 5,
+        "type": "bool"
+      },
+      {
+        "name": "MouseClickedCount[5]",
+        "size": 5,
+        "type": "ImU16"
+      },
+      {
+        "name": "MouseClickedLastCount[5]",
+        "size": 5,
+        "type": "ImU16"
+      },
+      {
+        "name": "MouseReleased[5]",
+        "size": 5,
+        "type": "bool"
+      },
+      {
+        "name": "MouseDownOwned[5]",
+        "size": 5,
+        "type": "bool"
+      },
+      {
+        "name": "MouseDownOwnedUnlessPopupClose[5]",
+        "size": 5,
+        "type": "bool"
+      },
+      {
+        "name": "MouseWheelRequestAxisSwap",
+        "type": "bool"
+      },
+      {
+        "name": "MouseCtrlLeftAsRightClick",
+        "type": "bool"
+      },
+      {
+        "name": "MouseDownDuration[5]",
+        "size": 5,
+        "type": "float"
+      },
+      {
+        "name": "MouseDownDurationPrev[5]",
+        "size": 5,
+        "type": "float"
+      },
+      {
+        "name": "MouseDragMaxDistanceAbs[5]",
+        "size": 5,
+        "type": "ImVec2"
+      },
+      {
+        "name": "MouseDragMaxDistanceSqr[5]",
+        "size": 5,
+        "type": "float"
+      },
+      {
+        "name": "PenPressure",
+        "type": "float"
+      },
+      {
+        "name": "AppFocusLost",
+        "type": "bool"
+      },
+      {
+        "name": "AppAcceptingEvents",
+        "type": "bool"
+      },
+      {
+        "name": "InputQueueSurrogate",
+        "type": "ImWchar16"
+      },
+      {
+        "name": "InputQueueCharacters",
+        "template_type": "ImWchar",
+        "type": "ImVector_ImWchar"
+      }
+    ],
+    "ImGuiInputEvent": [
+      {
+        "name": "Type",
+        "type": "ImGuiInputEventType"
+      },
+      {
+        "name": "Source",
+        "type": "ImGuiInputSource"
+      },
+      {
+        "name": "EventId",
+        "type": "ImU32"
+      },
+      {
+        "name": "",
+        "type": "union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;}"
+      },
+      {
+        "name": "AddedByTestEngine",
+        "type": "bool"
+      }
+    ],
+    "ImGuiInputEventAppFocused": [
+      {
+        "name": "Focused",
+        "type": "bool"
+      }
+    ],
+    "ImGuiInputEventKey": [
+      {
+        "name": "Key",
+        "type": "ImGuiKey"
+      },
+      {
+        "name": "Down",
+        "type": "bool"
+      },
+      {
+        "name": "AnalogValue",
+        "type": "float"
+      }
+    ],
+    "ImGuiInputEventMouseButton": [
+      {
+        "name": "Button",
+        "type": "int"
+      },
+      {
+        "name": "Down",
+        "type": "bool"
+      },
+      {
+        "name": "MouseSource",
+        "type": "ImGuiMouseSource"
+      }
+    ],
+    "ImGuiInputEventMousePos": [
+      {
+        "name": "PosX",
+        "type": "float"
+      },
+      {
+        "name": "PosY",
+        "type": "float"
+      },
+      {
+        "name": "MouseSource",
+        "type": "ImGuiMouseSource"
+      }
+    ],
+    "ImGuiInputEventMouseViewport": [
+      {
+        "name": "HoveredViewportID",
+        "type": "ImGuiID"
+      }
+    ],
+    "ImGuiInputEventMouseWheel": [
+      {
+        "name": "WheelX",
+        "type": "float"
+      },
+      {
+        "name": "WheelY",
+        "type": "float"
+      },
+      {
+        "name": "MouseSource",
+        "type": "ImGuiMouseSource"
+      }
+    ],
+    "ImGuiInputEventText": [
+      {
+        "name": "Char",
+        "type": "unsigned int"
+      }
+    ],
+    "ImGuiInputTextCallbackData": [
+      {
+        "name": "Ctx",
+        "type": "ImGuiContext*"
+      },
+      {
+        "name": "EventFlag",
+        "type": "ImGuiInputTextFlags"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiInputTextFlags"
+      },
+      {
+        "name": "UserData",
+        "type": "void*"
+      },
+      {
+        "name": "EventChar",
+        "type": "ImWchar"
+      },
+      {
+        "name": "EventKey",
+        "type": "ImGuiKey"
+      },
+      {
+        "name": "Buf",
+        "type": "char*"
+      },
+      {
+        "name": "BufTextLen",
+        "type": "int"
+      },
+      {
+        "name": "BufSize",
+        "type": "int"
+      },
+      {
+        "name": "BufDirty",
+        "type": "bool"
+      },
+      {
+        "name": "CursorPos",
+        "type": "int"
+      },
+      {
+        "name": "SelectionStart",
+        "type": "int"
+      },
+      {
+        "name": "SelectionEnd",
+        "type": "int"
+      }
+    ],
+    "ImGuiInputTextDeactivatedState": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "TextA",
+        "template_type": "char",
+        "type": "ImVector_char"
+      }
+    ],
+    "ImGuiInputTextState": [
+      {
+        "name": "Ctx",
+        "type": "ImGuiContext*"
+      },
+      {
+        "name": "Stb",
+        "type": "ImStbTexteditState*"
+      },
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "TextLen",
+        "type": "int"
+      },
+      {
+        "name": "TextA",
+        "template_type": "char",
+        "type": "ImVector_char"
+      },
+      {
+        "name": "TextToRevertTo",
+        "template_type": "char",
+        "type": "ImVector_char"
+      },
+      {
+        "name": "CallbackTextBackup",
+        "template_type": "char",
+        "type": "ImVector_char"
+      },
+      {
+        "name": "BufCapacity",
+        "type": "int"
+      },
+      {
+        "name": "Scroll",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CursorAnim",
+        "type": "float"
+      },
+      {
+        "name": "CursorFollow",
+        "type": "bool"
+      },
+      {
+        "name": "SelectedAllMouseLock",
+        "type": "bool"
+      },
+      {
+        "name": "Edited",
+        "type": "bool"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiInputTextFlags"
+      },
+      {
+        "name": "ReloadUserBuf",
+        "type": "bool"
+      },
+      {
+        "name": "ReloadSelectionStart",
+        "type": "int"
+      },
+      {
+        "name": "ReloadSelectionEnd",
+        "type": "int"
+      }
+    ],
+    "ImGuiKeyData": [
+      {
+        "name": "Down",
+        "type": "bool"
+      },
+      {
+        "name": "DownDuration",
+        "type": "float"
+      },
+      {
+        "name": "DownDurationPrev",
+        "type": "float"
+      },
+      {
+        "name": "AnalogValue",
+        "type": "float"
+      }
+    ],
+    "ImGuiKeyOwnerData": [
+      {
+        "name": "OwnerCurr",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "OwnerNext",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LockThisFrame",
+        "type": "bool"
+      },
+      {
+        "name": "LockUntilRelease",
+        "type": "bool"
+      }
+    ],
+    "ImGuiKeyRoutingData": [
+      {
+        "name": "NextEntryIndex",
+        "type": "ImGuiKeyRoutingIndex"
+      },
+      {
+        "name": "Mods",
+        "type": "ImU16"
+      },
+      {
+        "name": "RoutingCurrScore",
+        "type": "ImU8"
+      },
+      {
+        "name": "RoutingNextScore",
+        "type": "ImU8"
+      },
+      {
+        "name": "RoutingCurr",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "RoutingNext",
+        "type": "ImGuiID"
+      }
+    ],
+    "ImGuiKeyRoutingTable": [
+      {
+        "name": "Index[ImGuiKey_NamedKey_COUNT]",
+        "size": 154,
+        "type": "ImGuiKeyRoutingIndex"
+      },
+      {
+        "name": "Entries",
+        "template_type": "ImGuiKeyRoutingData",
+        "type": "ImVector_ImGuiKeyRoutingData"
+      },
+      {
+        "name": "EntriesNext",
+        "template_type": "ImGuiKeyRoutingData",
+        "type": "ImVector_ImGuiKeyRoutingData"
+      }
+    ],
+    "ImGuiLastItemData": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ItemFlags",
+        "type": "ImGuiItemFlags"
+      },
+      {
+        "name": "StatusFlags",
+        "type": "ImGuiItemStatusFlags"
+      },
+      {
+        "name": "Rect",
+        "type": "ImRect"
+      },
+      {
+        "name": "NavRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "DisplayRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "ClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "Shortcut",
+        "type": "ImGuiKeyChord"
+      }
+    ],
+    "ImGuiListClipper": [
+      {
+        "name": "Ctx",
+        "type": "ImGuiContext*"
+      },
+      {
+        "name": "DisplayStart",
+        "type": "int"
+      },
+      {
+        "name": "DisplayEnd",
+        "type": "int"
+      },
+      {
+        "name": "ItemsCount",
+        "type": "int"
+      },
+      {
+        "name": "ItemsHeight",
+        "type": "float"
+      },
+      {
+        "name": "StartPosY",
+        "type": "float"
+      },
+      {
+        "name": "StartSeekOffsetY",
+        "type": "double"
+      },
+      {
+        "name": "TempData",
+        "type": "void*"
+      }
+    ],
+    "ImGuiListClipperData": [
+      {
+        "name": "ListClipper",
+        "type": "ImGuiListClipper*"
+      },
+      {
+        "name": "LossynessOffset",
+        "type": "float"
+      },
+      {
+        "name": "StepNo",
+        "type": "int"
+      },
+      {
+        "name": "ItemsFrozen",
+        "type": "int"
+      },
+      {
+        "name": "Ranges",
+        "template_type": "ImGuiListClipperRange",
+        "type": "ImVector_ImGuiListClipperRange"
+      }
+    ],
+    "ImGuiListClipperRange": [
+      {
+        "name": "Min",
+        "type": "int"
+      },
+      {
+        "name": "Max",
+        "type": "int"
+      },
+      {
+        "name": "PosToIndexConvert",
+        "type": "bool"
+      },
+      {
+        "name": "PosToIndexOffsetMin",
+        "type": "ImS8"
+      },
+      {
+        "name": "PosToIndexOffsetMax",
+        "type": "ImS8"
+      }
+    ],
+    "ImGuiLocEntry": [
+      {
+        "name": "Key",
+        "type": "ImGuiLocKey"
+      },
+      {
+        "name": "Text",
+        "type": "const char*"
+      }
+    ],
+    "ImGuiMenuColumns": [
+      {
+        "name": "TotalWidth",
+        "type": "ImU32"
+      },
+      {
+        "name": "NextTotalWidth",
+        "type": "ImU32"
+      },
+      {
+        "name": "Spacing",
+        "type": "ImU16"
+      },
+      {
+        "name": "OffsetIcon",
+        "type": "ImU16"
+      },
+      {
+        "name": "OffsetLabel",
+        "type": "ImU16"
+      },
+      {
+        "name": "OffsetShortcut",
+        "type": "ImU16"
+      },
+      {
+        "name": "OffsetMark",
+        "type": "ImU16"
+      },
+      {
+        "name": "Widths[4]",
+        "size": 4,
+        "type": "ImU16"
+      }
+    ],
+    "ImGuiMetricsConfig": [
+      {
+        "name": "ShowDebugLog",
+        "type": "bool"
+      },
+      {
+        "name": "ShowIDStackTool",
+        "type": "bool"
+      },
+      {
+        "name": "ShowWindowsRects",
+        "type": "bool"
+      },
+      {
+        "name": "ShowWindowsBeginOrder",
+        "type": "bool"
+      },
+      {
+        "name": "ShowTablesRects",
+        "type": "bool"
+      },
+      {
+        "name": "ShowDrawCmdMesh",
+        "type": "bool"
+      },
+      {
+        "name": "ShowDrawCmdBoundingBoxes",
+        "type": "bool"
+      },
+      {
+        "name": "ShowTextEncodingViewer",
+        "type": "bool"
+      },
+      {
+        "name": "ShowAtlasTintedWithTextColor",
+        "type": "bool"
+      },
+      {
+        "name": "ShowDockingNodes",
+        "type": "bool"
+      },
+      {
+        "name": "ShowWindowsRectsType",
+        "type": "int"
+      },
+      {
+        "name": "ShowTablesRectsType",
+        "type": "int"
+      },
+      {
+        "name": "HighlightMonitorIdx",
+        "type": "int"
+      },
+      {
+        "name": "HighlightViewportID",
+        "type": "ImGuiID"
+      }
+    ],
+    "ImGuiMultiSelectIO": [
+      {
+        "name": "Requests",
+        "template_type": "ImGuiSelectionRequest",
+        "type": "ImVector_ImGuiSelectionRequest"
+      },
+      {
+        "name": "RangeSrcItem",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "NavIdItem",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "NavIdSelected",
+        "type": "bool"
+      },
+      {
+        "name": "RangeSrcReset",
+        "type": "bool"
+      },
+      {
+        "name": "ItemsCount",
+        "type": "int"
+      }
+    ],
+    "ImGuiMultiSelectState": [
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LastFrameActive",
+        "type": "int"
+      },
+      {
+        "name": "LastSelectionSize",
+        "type": "int"
+      },
+      {
+        "name": "RangeSelected",
+        "type": "ImS8"
+      },
+      {
+        "name": "NavIdSelected",
+        "type": "ImS8"
+      },
+      {
+        "name": "RangeSrcItem",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "NavIdItem",
+        "type": "ImGuiSelectionUserData"
+      }
+    ],
+    "ImGuiMultiSelectTempData": [
+      {
+        "name": "IO",
+        "type": "ImGuiMultiSelectIO"
+      },
+      {
+        "name": "Storage",
+        "type": "ImGuiMultiSelectState*"
+      },
+      {
+        "name": "FocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiMultiSelectFlags"
+      },
+      {
+        "name": "ScopeRectMin",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCursorMaxPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LastSubmittedItem",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "BoxSelectId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "KeyMods",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "LoopRequestSetAll",
+        "type": "ImS8"
+      },
+      {
+        "name": "IsEndIO",
+        "type": "bool"
+      },
+      {
+        "name": "IsFocused",
+        "type": "bool"
+      },
+      {
+        "name": "IsKeyboardSetRange",
+        "type": "bool"
+      },
+      {
+        "name": "NavIdPassedBy",
+        "type": "bool"
+      },
+      {
+        "name": "RangeSrcPassedBy",
+        "type": "bool"
+      },
+      {
+        "name": "RangeDstPassedBy",
+        "type": "bool"
+      }
+    ],
+    "ImGuiNavItemData": [
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "FocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "RectRel",
+        "type": "ImRect"
+      },
+      {
+        "name": "ItemFlags",
+        "type": "ImGuiItemFlags"
+      },
+      {
+        "name": "DistBox",
+        "type": "float"
+      },
+      {
+        "name": "DistCenter",
+        "type": "float"
+      },
+      {
+        "name": "DistAxial",
+        "type": "float"
+      },
+      {
+        "name": "SelectionUserData",
+        "type": "ImGuiSelectionUserData"
+      }
+    ],
+    "ImGuiNextItemData": [
+      {
+        "name": "HasFlags",
+        "type": "ImGuiNextItemDataFlags"
+      },
+      {
+        "name": "ItemFlags",
+        "type": "ImGuiItemFlags"
+      },
+      {
+        "name": "FocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "SelectionUserData",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "Width",
+        "type": "float"
+      },
+      {
+        "name": "Shortcut",
+        "type": "ImGuiKeyChord"
+      },
+      {
+        "name": "ShortcutFlags",
+        "type": "ImGuiInputFlags"
+      },
+      {
+        "name": "OpenVal",
+        "type": "bool"
+      },
+      {
+        "name": "OpenCond",
+        "type": "ImU8"
+      },
+      {
+        "name": "RefVal",
+        "type": "ImGuiDataTypeStorage"
+      },
+      {
+        "name": "StorageId",
+        "type": "ImGuiID"
+      }
+    ],
+    "ImGuiNextWindowData": [
+      {
+        "name": "Flags",
+        "type": "ImGuiNextWindowDataFlags"
+      },
+      {
+        "name": "PosCond",
+        "type": "ImGuiCond"
+      },
+      {
+        "name": "SizeCond",
+        "type": "ImGuiCond"
+      },
+      {
+        "name": "CollapsedCond",
+        "type": "ImGuiCond"
+      },
+      {
+        "name": "DockCond",
+        "type": "ImGuiCond"
+      },
+      {
+        "name": "PosVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "PosPivotVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SizeVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ContentSizeVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ChildFlags",
+        "type": "ImGuiChildFlags"
+      },
+      {
+        "name": "PosUndock",
+        "type": "bool"
+      },
+      {
+        "name": "CollapsedVal",
+        "type": "bool"
+      },
+      {
+        "name": "SizeConstraintRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "SizeCallback",
+        "type": "ImGuiSizeCallback"
+      },
+      {
+        "name": "SizeCallbackUserData",
+        "type": "void*"
+      },
+      {
+        "name": "BgAlphaVal",
+        "type": "float"
+      },
+      {
+        "name": "ViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DockId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "WindowClass",
+        "type": "ImGuiWindowClass"
+      },
+      {
+        "name": "MenuBarOffsetMinVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "RefreshFlagsVal",
+        "type": "ImGuiWindowRefreshFlags"
+      }
+    ],
+    "ImGuiOldColumnData": [
+      {
+        "name": "OffsetNorm",
+        "type": "float"
+      },
+      {
+        "name": "OffsetNormBeforeResize",
+        "type": "float"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiOldColumnFlags"
+      },
+      {
+        "name": "ClipRect",
+        "type": "ImRect"
+      }
+    ],
+    "ImGuiOldColumns": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiOldColumnFlags"
+      },
+      {
+        "name": "IsFirstFrame",
+        "type": "bool"
+      },
+      {
+        "name": "IsBeingResized",
+        "type": "bool"
+      },
+      {
+        "name": "Current",
+        "type": "int"
+      },
+      {
+        "name": "Count",
+        "type": "int"
+      },
+      {
+        "name": "OffMinX",
+        "type": "float"
+      },
+      {
+        "name": "OffMaxX",
+        "type": "float"
+      },
+      {
+        "name": "LineMinY",
+        "type": "float"
+      },
+      {
+        "name": "LineMaxY",
+        "type": "float"
+      },
+      {
+        "name": "HostCursorPosY",
+        "type": "float"
+      },
+      {
+        "name": "HostCursorMaxPosX",
+        "type": "float"
+      },
+      {
+        "name": "HostInitialClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "HostBackupClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "HostBackupParentWorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "Columns",
+        "template_type": "ImGuiOldColumnData",
+        "type": "ImVector_ImGuiOldColumnData"
+      },
+      {
+        "name": "Splitter",
+        "type": "ImDrawListSplitter"
+      }
+    ],
+    "ImGuiOnceUponAFrame": [
+      {
+        "name": "RefFrame",
+        "type": "int"
+      }
+    ],
+    "ImGuiPayload": [
+      {
+        "name": "Data",
+        "type": "void*"
+      },
+      {
+        "name": "DataSize",
+        "type": "int"
+      },
+      {
+        "name": "SourceId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "SourceParentId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DataFrameCount",
+        "type": "int"
+      },
+      {
+        "name": "DataType[32+1]",
+        "size": 33,
+        "type": "char"
+      },
+      {
+        "name": "Preview",
+        "type": "bool"
+      },
+      {
+        "name": "Delivery",
+        "type": "bool"
+      }
+    ],
+    "ImGuiPlatformIO": [
+      {
+        "name": "Platform_GetClipboardTextFn",
+        "type": "const char*(*)(ImGuiContext* ctx)"
+      },
+      {
+        "name": "Platform_SetClipboardTextFn",
+        "type": "void(*)(ImGuiContext* ctx,const char* text)"
+      },
+      {
+        "name": "Platform_ClipboardUserData",
+        "type": "void*"
+      },
+      {
+        "name": "Platform_OpenInShellFn",
+        "type": "bool(*)(ImGuiContext* ctx,const char* path)"
+      },
+      {
+        "name": "Platform_OpenInShellUserData",
+        "type": "void*"
+      },
+      {
+        "name": "Platform_SetImeDataFn",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiViewport* viewport,ImGuiPlatformImeData* data)"
+      },
+      {
+        "name": "Platform_ImeUserData",
+        "type": "void*"
+      },
+      {
+        "name": "Platform_LocaleDecimalPoint",
+        "type": "ImWchar"
+      },
+      {
+        "name": "Renderer_RenderState",
+        "type": "void*"
+      },
+      {
+        "name": "Platform_CreateWindow",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_DestroyWindow",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_ShowWindow",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_SetWindowPos",
+        "type": "void(*)(ImGuiViewport* vp,ImVec2 pos)"
+      },
+      {
+        "name": "Platform_GetWindowPos",
+        "type": "ImVec2(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_SetWindowSize",
+        "type": "void(*)(ImGuiViewport* vp,ImVec2 size)"
+      },
+      {
+        "name": "Platform_GetWindowSize",
+        "type": "ImVec2(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_SetWindowFocus",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_GetWindowFocus",
+        "type": "bool(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_GetWindowMinimized",
+        "type": "bool(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_SetWindowTitle",
+        "type": "void(*)(ImGuiViewport* vp,const char* str)"
+      },
+      {
+        "name": "Platform_SetWindowAlpha",
+        "type": "void(*)(ImGuiViewport* vp,float alpha)"
+      },
+      {
+        "name": "Platform_UpdateWindow",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_RenderWindow",
+        "type": "void(*)(ImGuiViewport* vp,void* render_arg)"
+      },
+      {
+        "name": "Platform_SwapBuffers",
+        "type": "void(*)(ImGuiViewport* vp,void* render_arg)"
+      },
+      {
+        "name": "Platform_GetWindowDpiScale",
+        "type": "float(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_OnChangedViewport",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_GetWindowWorkAreaInsets",
+        "type": "ImVec4(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Platform_CreateVkSurface",
+        "type": "int(*)(ImGuiViewport* vp,ImU64 vk_inst,const void* vk_allocators,ImU64* out_vk_surface)"
+      },
+      {
+        "name": "Renderer_CreateWindow",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Renderer_DestroyWindow",
+        "type": "void(*)(ImGuiViewport* vp)"
+      },
+      {
+        "name": "Renderer_SetWindowSize",
+        "type": "void(*)(ImGuiViewport* vp,ImVec2 size)"
+      },
+      {
+        "name": "Renderer_RenderWindow",
+        "type": "void(*)(ImGuiViewport* vp,void* render_arg)"
+      },
+      {
+        "name": "Renderer_SwapBuffers",
+        "type": "void(*)(ImGuiViewport* vp,void* render_arg)"
+      },
+      {
+        "name": "Monitors",
+        "template_type": "ImGuiPlatformMonitor",
+        "type": "ImVector_ImGuiPlatformMonitor"
+      },
+      {
+        "name": "Viewports",
+        "template_type": "ImGuiViewport*",
+        "type": "ImVector_ImGuiViewportPtr"
+      }
+    ],
+    "ImGuiPlatformImeData": [
+      {
+        "name": "WantVisible",
+        "type": "bool"
+      },
+      {
+        "name": "InputPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "InputLineHeight",
+        "type": "float"
+      }
+    ],
+    "ImGuiPlatformMonitor": [
+      {
+        "name": "MainPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MainSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WorkPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WorkSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DpiScale",
+        "type": "float"
+      },
+      {
+        "name": "PlatformHandle",
+        "type": "void*"
+      }
+    ],
+    "ImGuiPopupData": [
+      {
+        "name": "PopupId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "RestoreNavWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ParentNavLayer",
+        "type": "int"
+      },
+      {
+        "name": "OpenFrameCount",
+        "type": "int"
+      },
+      {
+        "name": "OpenParentId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "OpenPopupPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "OpenMousePos",
+        "type": "ImVec2"
+      }
+    ],
+    "ImGuiPtrOrIndex": [
+      {
+        "name": "Ptr",
+        "type": "void*"
+      },
+      {
+        "name": "Index",
+        "type": "int"
+      }
+    ],
+    "ImGuiSelectionBasicStorage": [
+      {
+        "name": "Size",
+        "type": "int"
+      },
+      {
+        "name": "PreserveOrder",
+        "type": "bool"
+      },
+      {
+        "name": "UserData",
+        "type": "void*"
+      },
+      {
+        "name": "AdapterIndexToStorageId",
+        "type": "ImGuiID(*)(ImGuiSelectionBasicStorage* self,int idx)"
+      },
+      {
+        "name": "_SelectionOrder",
+        "type": "int"
+      },
+      {
+        "name": "_Storage",
+        "type": "ImGuiStorage"
+      }
+    ],
+    "ImGuiSelectionExternalStorage": [
+      {
+        "name": "UserData",
+        "type": "void*"
+      },
+      {
+        "name": "AdapterSetItemSelected",
+        "type": "void(*)(ImGuiSelectionExternalStorage* self,int idx,bool selected)"
+      }
+    ],
+    "ImGuiSelectionRequest": [
+      {
+        "name": "Type",
+        "type": "ImGuiSelectionRequestType"
+      },
+      {
+        "name": "Selected",
+        "type": "bool"
+      },
+      {
+        "name": "RangeDirection",
+        "type": "ImS8"
+      },
+      {
+        "name": "RangeFirstItem",
+        "type": "ImGuiSelectionUserData"
+      },
+      {
+        "name": "RangeLastItem",
+        "type": "ImGuiSelectionUserData"
+      }
+    ],
+    "ImGuiSettingsHandler": [
+      {
+        "name": "TypeName",
+        "type": "const char*"
+      },
+      {
+        "name": "TypeHash",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ClearAllFn",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiSettingsHandler* handler)"
+      },
+      {
+        "name": "ReadInitFn",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiSettingsHandler* handler)"
+      },
+      {
+        "name": "ReadOpenFn",
+        "type": "void*(*)(ImGuiContext* ctx,ImGuiSettingsHandler* handler,const char* name)"
+      },
+      {
+        "name": "ReadLineFn",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiSettingsHandler* handler,void* entry,const char* line)"
+      },
+      {
+        "name": "ApplyAllFn",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiSettingsHandler* handler)"
+      },
+      {
+        "name": "WriteAllFn",
+        "type": "void(*)(ImGuiContext* ctx,ImGuiSettingsHandler* handler,ImGuiTextBuffer* out_buf)"
+      },
+      {
+        "name": "UserData",
+        "type": "void*"
+      }
+    ],
+    "ImGuiShrinkWidthItem": [
+      {
+        "name": "Index",
+        "type": "int"
+      },
+      {
+        "name": "Width",
+        "type": "float"
+      },
+      {
+        "name": "InitialWidth",
+        "type": "float"
+      }
+    ],
+    "ImGuiSizeCallbackData": [
+      {
+        "name": "UserData",
+        "type": "void*"
+      },
+      {
+        "name": "Pos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CurrentSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DesiredSize",
+        "type": "ImVec2"
+      }
+    ],
+    "ImGuiStackLevelInfo": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "QueryFrameCount",
+        "type": "ImS8"
+      },
+      {
+        "name": "QuerySuccess",
+        "type": "bool"
+      },
+      {
+        "bitfield": "8",
+        "name": "DataType",
+        "type": "ImGuiDataType"
+      },
+      {
+        "name": "Desc[57]",
+        "size": 57,
+        "type": "char"
+      }
+    ],
+    "ImGuiStorage": [
+      {
+        "name": "Data",
+        "template_type": "ImGuiStoragePair",
+        "type": "ImVector_ImGuiStoragePair"
+      }
+    ],
+    "ImGuiStoragePair": [
+      {
+        "name": "key",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "",
+        "type": "union { int val_i; float val_f; void* val_p;}"
+      }
+    ],
+    "ImGuiStyle": [
+      {
+        "name": "Alpha",
+        "type": "float"
+      },
+      {
+        "name": "DisabledAlpha",
+        "type": "float"
+      },
+      {
+        "name": "WindowPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WindowRounding",
+        "type": "float"
+      },
+      {
+        "name": "WindowBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "WindowMinSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WindowTitleAlign",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WindowMenuButtonPosition",
+        "type": "ImGuiDir"
+      },
+      {
+        "name": "ChildRounding",
+        "type": "float"
+      },
+      {
+        "name": "ChildBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "PopupRounding",
+        "type": "float"
+      },
+      {
+        "name": "PopupBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "FramePadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "FrameRounding",
+        "type": "float"
+      },
+      {
+        "name": "FrameBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "ItemSpacing",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ItemInnerSpacing",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CellPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "TouchExtraPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "IndentSpacing",
+        "type": "float"
+      },
+      {
+        "name": "ColumnsMinSpacing",
+        "type": "float"
+      },
+      {
+        "name": "ScrollbarSize",
+        "type": "float"
+      },
+      {
+        "name": "ScrollbarRounding",
+        "type": "float"
+      },
+      {
+        "name": "GrabMinSize",
+        "type": "float"
+      },
+      {
+        "name": "GrabRounding",
+        "type": "float"
+      },
+      {
+        "name": "LogSliderDeadzone",
+        "type": "float"
+      },
+      {
+        "name": "TabRounding",
+        "type": "float"
+      },
+      {
+        "name": "TabBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "TabMinWidthForCloseButton",
+        "type": "float"
+      },
+      {
+        "name": "TabBarBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "TabBarOverlineSize",
+        "type": "float"
+      },
+      {
+        "name": "TableAngledHeadersAngle",
+        "type": "float"
+      },
+      {
+        "name": "TableAngledHeadersTextAlign",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ColorButtonPosition",
+        "type": "ImGuiDir"
+      },
+      {
+        "name": "ButtonTextAlign",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SelectableTextAlign",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SeparatorTextBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "SeparatorTextAlign",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SeparatorTextPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DisplayWindowPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DisplaySafeAreaPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DockingSeparatorSize",
+        "type": "float"
+      },
+      {
+        "name": "MouseCursorScale",
+        "type": "float"
+      },
+      {
+        "name": "AntiAliasedLines",
+        "type": "bool"
+      },
+      {
+        "name": "AntiAliasedLinesUseTex",
+        "type": "bool"
+      },
+      {
+        "name": "AntiAliasedFill",
+        "type": "bool"
+      },
+      {
+        "name": "CurveTessellationTol",
+        "type": "float"
+      },
+      {
+        "name": "CircleTessellationMaxError",
+        "type": "float"
+      },
+      {
+        "name": "Colors[ImGuiCol_COUNT]",
+        "size": 58,
+        "type": "ImVec4"
+      },
+      {
+        "name": "HoverStationaryDelay",
+        "type": "float"
+      },
+      {
+        "name": "HoverDelayShort",
+        "type": "float"
+      },
+      {
+        "name": "HoverDelayNormal",
+        "type": "float"
+      },
+      {
+        "name": "HoverFlagsForTooltipMouse",
+        "type": "ImGuiHoveredFlags"
+      },
+      {
+        "name": "HoverFlagsForTooltipNav",
+        "type": "ImGuiHoveredFlags"
+      }
+    ],
+    "ImGuiStyleMod": [
+      {
+        "name": "VarIdx",
+        "type": "ImGuiStyleVar"
+      },
+      {
+        "name": "",
+        "type": "union { int BackupInt[2]; float BackupFloat[2];}"
+      }
+    ],
+    "ImGuiTabBar": [
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "Tabs",
+        "template_type": "ImGuiTabItem",
+        "type": "ImVector_ImGuiTabItem"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiTabBarFlags"
+      },
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "SelectedTabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NextSelectedTabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "VisibleTabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "CurrFrameVisible",
+        "type": "int"
+      },
+      {
+        "name": "PrevFrameVisible",
+        "type": "int"
+      },
+      {
+        "name": "BarRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "CurrTabsContentsHeight",
+        "type": "float"
+      },
+      {
+        "name": "PrevTabsContentsHeight",
+        "type": "float"
+      },
+      {
+        "name": "WidthAllTabs",
+        "type": "float"
+      },
+      {
+        "name": "WidthAllTabsIdeal",
+        "type": "float"
+      },
+      {
+        "name": "ScrollingAnim",
+        "type": "float"
+      },
+      {
+        "name": "ScrollingTarget",
+        "type": "float"
+      },
+      {
+        "name": "ScrollingTargetDistToVisibility",
+        "type": "float"
+      },
+      {
+        "name": "ScrollingSpeed",
+        "type": "float"
+      },
+      {
+        "name": "ScrollingRectMinX",
+        "type": "float"
+      },
+      {
+        "name": "ScrollingRectMaxX",
+        "type": "float"
+      },
+      {
+        "name": "SeparatorMinX",
+        "type": "float"
+      },
+      {
+        "name": "SeparatorMaxX",
+        "type": "float"
+      },
+      {
+        "name": "ReorderRequestTabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ReorderRequestOffset",
+        "type": "ImS16"
+      },
+      {
+        "name": "BeginCount",
+        "type": "ImS8"
+      },
+      {
+        "name": "WantLayout",
+        "type": "bool"
+      },
+      {
+        "name": "VisibleTabWasSubmitted",
+        "type": "bool"
+      },
+      {
+        "name": "TabsAddedNew",
+        "type": "bool"
+      },
+      {
+        "name": "TabsActiveCount",
+        "type": "ImS16"
+      },
+      {
+        "name": "LastTabItemIdx",
+        "type": "ImS16"
+      },
+      {
+        "name": "ItemSpacingY",
+        "type": "float"
+      },
+      {
+        "name": "FramePadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BackupCursorPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "TabsNames",
+        "type": "ImGuiTextBuffer"
+      }
+    ],
+    "ImGuiTabItem": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiTabItemFlags"
+      },
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "LastFrameVisible",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameSelected",
+        "type": "int"
+      },
+      {
+        "name": "Offset",
+        "type": "float"
+      },
+      {
+        "name": "Width",
+        "type": "float"
+      },
+      {
+        "name": "ContentWidth",
+        "type": "float"
+      },
+      {
+        "name": "RequestedWidth",
+        "type": "float"
+      },
+      {
+        "name": "NameOffset",
+        "type": "ImS32"
+      },
+      {
+        "name": "BeginOrder",
+        "type": "ImS16"
+      },
+      {
+        "name": "IndexDuringLayout",
+        "type": "ImS16"
+      },
+      {
+        "name": "WantClose",
+        "type": "bool"
+      }
+    ],
+    "ImGuiTable": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiTableFlags"
+      },
+      {
+        "name": "RawData",
+        "type": "void*"
+      },
+      {
+        "name": "TempData",
+        "type": "ImGuiTableTempData*"
+      },
+      {
+        "name": "Columns",
+        "template_type": "ImGuiTableColumn",
+        "type": "ImSpan_ImGuiTableColumn"
+      },
+      {
+        "name": "DisplayOrderToIndex",
+        "template_type": "ImGuiTableColumnIdx",
+        "type": "ImSpan_ImGuiTableColumnIdx"
+      },
+      {
+        "name": "RowCellData",
+        "template_type": "ImGuiTableCellData",
+        "type": "ImSpan_ImGuiTableCellData"
+      },
+      {
+        "name": "EnabledMaskByDisplayOrder",
+        "type": "ImBitArrayPtr"
+      },
+      {
+        "name": "EnabledMaskByIndex",
+        "type": "ImBitArrayPtr"
+      },
+      {
+        "name": "VisibleMaskByIndex",
+        "type": "ImBitArrayPtr"
+      },
+      {
+        "name": "SettingsLoadedFlags",
+        "type": "ImGuiTableFlags"
+      },
+      {
+        "name": "SettingsOffset",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameActive",
+        "type": "int"
+      },
+      {
+        "name": "ColumnsCount",
+        "type": "int"
+      },
+      {
+        "name": "CurrentRow",
+        "type": "int"
+      },
+      {
+        "name": "CurrentColumn",
+        "type": "int"
+      },
+      {
+        "name": "InstanceCurrent",
+        "type": "ImS16"
+      },
+      {
+        "name": "InstanceInteracted",
+        "type": "ImS16"
+      },
+      {
+        "name": "RowPosY1",
+        "type": "float"
+      },
+      {
+        "name": "RowPosY2",
+        "type": "float"
+      },
+      {
+        "name": "RowMinHeight",
+        "type": "float"
+      },
+      {
+        "name": "RowCellPaddingY",
+        "type": "float"
+      },
+      {
+        "name": "RowTextBaseline",
+        "type": "float"
+      },
+      {
+        "name": "RowIndentOffsetX",
+        "type": "float"
+      },
+      {
+        "bitfield": "16",
+        "name": "RowFlags",
+        "type": "ImGuiTableRowFlags"
+      },
+      {
+        "bitfield": "16",
+        "name": "LastRowFlags",
+        "type": "ImGuiTableRowFlags"
+      },
+      {
+        "name": "RowBgColorCounter",
+        "type": "int"
+      },
+      {
+        "name": "RowBgColor[2]",
+        "size": 2,
+        "type": "ImU32"
+      },
+      {
+        "name": "BorderColorStrong",
+        "type": "ImU32"
+      },
+      {
+        "name": "BorderColorLight",
+        "type": "ImU32"
+      },
+      {
+        "name": "BorderX1",
+        "type": "float"
+      },
+      {
+        "name": "BorderX2",
+        "type": "float"
+      },
+      {
+        "name": "HostIndentX",
+        "type": "float"
+      },
+      {
+        "name": "MinColumnWidth",
+        "type": "float"
+      },
+      {
+        "name": "OuterPaddingX",
+        "type": "float"
+      },
+      {
+        "name": "CellPaddingX",
+        "type": "float"
+      },
+      {
+        "name": "CellSpacingX1",
+        "type": "float"
+      },
+      {
+        "name": "CellSpacingX2",
+        "type": "float"
+      },
+      {
+        "name": "InnerWidth",
+        "type": "float"
+      },
+      {
+        "name": "ColumnsGivenWidth",
+        "type": "float"
+      },
+      {
+        "name": "ColumnsAutoFitWidth",
+        "type": "float"
+      },
+      {
+        "name": "ColumnsStretchSumWeights",
+        "type": "float"
+      },
+      {
+        "name": "ResizedColumnNextWidth",
+        "type": "float"
+      },
+      {
+        "name": "ResizeLockMinContentsX2",
+        "type": "float"
+      },
+      {
+        "name": "RefScale",
+        "type": "float"
+      },
+      {
+        "name": "AngledHeadersHeight",
+        "type": "float"
+      },
+      {
+        "name": "AngledHeadersSlope",
+        "type": "float"
+      },
+      {
+        "name": "OuterRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "InnerRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "WorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "InnerClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "BgClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "Bg0ClipRectForDrawCmd",
+        "type": "ImRect"
+      },
+      {
+        "name": "Bg2ClipRectForDrawCmd",
+        "type": "ImRect"
+      },
+      {
+        "name": "HostClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "HostBackupInnerClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "OuterWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "InnerWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ColumnsNames",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "DrawSplitter",
+        "type": "ImDrawListSplitter*"
+      },
+      {
+        "name": "InstanceDataFirst",
+        "type": "ImGuiTableInstanceData"
+      },
+      {
+        "name": "InstanceDataExtra",
+        "template_type": "ImGuiTableInstanceData",
+        "type": "ImVector_ImGuiTableInstanceData"
+      },
+      {
+        "name": "SortSpecsSingle",
+        "type": "ImGuiTableColumnSortSpecs"
+      },
+      {
+        "name": "SortSpecsMulti",
+        "template_type": "ImGuiTableColumnSortSpecs",
+        "type": "ImVector_ImGuiTableColumnSortSpecs"
+      },
+      {
+        "name": "SortSpecs",
+        "type": "ImGuiTableSortSpecs"
+      },
+      {
+        "name": "SortSpecsCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ColumnsEnabledCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ColumnsEnabledFixedCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "DeclColumnsCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "AngledHeadersCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "HoveredColumnBody",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "HoveredColumnBorder",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "HighlightColumnHeader",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "AutoFitSingleColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ResizedColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "LastResizedColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "HeldHeaderColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ReorderColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ReorderColumnDir",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "LeftMostEnabledColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "RightMostEnabledColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "LeftMostStretchedColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "RightMostStretchedColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ContextPopupColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "FreezeRowsRequest",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "FreezeRowsCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "FreezeColumnsRequest",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "FreezeColumnsCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "RowCellDataCurrent",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "DummyDrawChannel",
+        "type": "ImGuiTableDrawChannelIdx"
+      },
+      {
+        "name": "Bg2DrawChannelCurrent",
+        "type": "ImGuiTableDrawChannelIdx"
+      },
+      {
+        "name": "Bg2DrawChannelUnfrozen",
+        "type": "ImGuiTableDrawChannelIdx"
+      },
+      {
+        "name": "IsLayoutLocked",
+        "type": "bool"
+      },
+      {
+        "name": "IsInsideRow",
+        "type": "bool"
+      },
+      {
+        "name": "IsInitializing",
+        "type": "bool"
+      },
+      {
+        "name": "IsSortSpecsDirty",
+        "type": "bool"
+      },
+      {
+        "name": "IsUsingHeaders",
+        "type": "bool"
+      },
+      {
+        "name": "IsContextPopupOpen",
+        "type": "bool"
+      },
+      {
+        "name": "DisableDefaultContextMenu",
+        "type": "bool"
+      },
+      {
+        "name": "IsSettingsRequestLoad",
+        "type": "bool"
+      },
+      {
+        "name": "IsSettingsDirty",
+        "type": "bool"
+      },
+      {
+        "name": "IsDefaultDisplayOrder",
+        "type": "bool"
+      },
+      {
+        "name": "IsResetAllRequest",
+        "type": "bool"
+      },
+      {
+        "name": "IsResetDisplayOrderRequest",
+        "type": "bool"
+      },
+      {
+        "name": "IsUnfrozenRows",
+        "type": "bool"
+      },
+      {
+        "name": "IsDefaultSizingPolicy",
+        "type": "bool"
+      },
+      {
+        "name": "IsActiveIdAliveBeforeTable",
+        "type": "bool"
+      },
+      {
+        "name": "IsActiveIdInTable",
+        "type": "bool"
+      },
+      {
+        "name": "HasScrollbarYCurr",
+        "type": "bool"
+      },
+      {
+        "name": "HasScrollbarYPrev",
+        "type": "bool"
+      },
+      {
+        "name": "MemoryCompacted",
+        "type": "bool"
+      },
+      {
+        "name": "HostSkipItems",
+        "type": "bool"
+      }
+    ],
+    "ImGuiTableCellData": [
+      {
+        "name": "BgColor",
+        "type": "ImU32"
+      },
+      {
+        "name": "Column",
+        "type": "ImGuiTableColumnIdx"
+      }
+    ],
+    "ImGuiTableColumn": [
+      {
+        "name": "Flags",
+        "type": "ImGuiTableColumnFlags"
+      },
+      {
+        "name": "WidthGiven",
+        "type": "float"
+      },
+      {
+        "name": "MinX",
+        "type": "float"
+      },
+      {
+        "name": "MaxX",
+        "type": "float"
+      },
+      {
+        "name": "WidthRequest",
+        "type": "float"
+      },
+      {
+        "name": "WidthAuto",
+        "type": "float"
+      },
+      {
+        "name": "WidthMax",
+        "type": "float"
+      },
+      {
+        "name": "StretchWeight",
+        "type": "float"
+      },
+      {
+        "name": "InitStretchWeightOrWidth",
+        "type": "float"
+      },
+      {
+        "name": "ClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "UserID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "WorkMinX",
+        "type": "float"
+      },
+      {
+        "name": "WorkMaxX",
+        "type": "float"
+      },
+      {
+        "name": "ItemWidth",
+        "type": "float"
+      },
+      {
+        "name": "ContentMaxXFrozen",
+        "type": "float"
+      },
+      {
+        "name": "ContentMaxXUnfrozen",
+        "type": "float"
+      },
+      {
+        "name": "ContentMaxXHeadersUsed",
+        "type": "float"
+      },
+      {
+        "name": "ContentMaxXHeadersIdeal",
+        "type": "float"
+      },
+      {
+        "name": "NameOffset",
+        "type": "ImS16"
+      },
+      {
+        "name": "DisplayOrder",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "IndexWithinEnabledSet",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "PrevEnabledColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "NextEnabledColumn",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "SortOrder",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "DrawChannelCurrent",
+        "type": "ImGuiTableDrawChannelIdx"
+      },
+      {
+        "name": "DrawChannelFrozen",
+        "type": "ImGuiTableDrawChannelIdx"
+      },
+      {
+        "name": "DrawChannelUnfrozen",
+        "type": "ImGuiTableDrawChannelIdx"
+      },
+      {
+        "name": "IsEnabled",
+        "type": "bool"
+      },
+      {
+        "name": "IsUserEnabled",
+        "type": "bool"
+      },
+      {
+        "name": "IsUserEnabledNextFrame",
+        "type": "bool"
+      },
+      {
+        "name": "IsVisibleX",
+        "type": "bool"
+      },
+      {
+        "name": "IsVisibleY",
+        "type": "bool"
+      },
+      {
+        "name": "IsRequestOutput",
+        "type": "bool"
+      },
+      {
+        "name": "IsSkipItems",
+        "type": "bool"
+      },
+      {
+        "name": "IsPreserveWidthAuto",
+        "type": "bool"
+      },
+      {
+        "name": "NavLayerCurrent",
+        "type": "ImS8"
+      },
+      {
+        "name": "AutoFitQueue",
+        "type": "ImU8"
+      },
+      {
+        "name": "CannotSkipItemsQueue",
+        "type": "ImU8"
+      },
+      {
+        "bitfield": "2",
+        "name": "SortDirection",
+        "type": "ImU8"
+      },
+      {
+        "bitfield": "2",
+        "name": "SortDirectionsAvailCount",
+        "type": "ImU8"
+      },
+      {
+        "bitfield": "4",
+        "name": "SortDirectionsAvailMask",
+        "type": "ImU8"
+      },
+      {
+        "name": "SortDirectionsAvailList",
+        "type": "ImU8"
+      }
+    ],
+    "ImGuiTableColumnSettings": [
+      {
+        "name": "WidthOrWeight",
+        "type": "float"
+      },
+      {
+        "name": "UserID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Index",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "DisplayOrder",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "SortOrder",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "bitfield": "2",
+        "name": "SortDirection",
+        "type": "ImU8"
+      },
+      {
+        "bitfield": "1",
+        "name": "IsEnabled",
+        "type": "ImU8"
+      },
+      {
+        "bitfield": "1",
+        "name": "IsStretch",
+        "type": "ImU8"
+      }
+    ],
+    "ImGuiTableColumnSortSpecs": [
+      {
+        "name": "ColumnUserID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ColumnIndex",
+        "type": "ImS16"
+      },
+      {
+        "name": "SortOrder",
+        "type": "ImS16"
+      },
+      {
+        "name": "SortDirection",
+        "type": "ImGuiSortDirection"
+      }
+    ],
+    "ImGuiTableHeaderData": [
+      {
+        "name": "Index",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "TextColor",
+        "type": "ImU32"
+      },
+      {
+        "name": "BgColor0",
+        "type": "ImU32"
+      },
+      {
+        "name": "BgColor1",
+        "type": "ImU32"
+      }
+    ],
+    "ImGuiTableInstanceData": [
+      {
+        "name": "TableInstanceID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LastOuterHeight",
+        "type": "float"
+      },
+      {
+        "name": "LastTopHeadersRowHeight",
+        "type": "float"
+      },
+      {
+        "name": "LastFrozenHeight",
+        "type": "float"
+      },
+      {
+        "name": "HoveredRowLast",
+        "type": "int"
+      },
+      {
+        "name": "HoveredRowNext",
+        "type": "int"
+      }
+    ],
+    "ImGuiTableSettings": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "SaveFlags",
+        "type": "ImGuiTableFlags"
+      },
+      {
+        "name": "RefScale",
+        "type": "float"
+      },
+      {
+        "name": "ColumnsCount",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "ColumnsCountMax",
+        "type": "ImGuiTableColumnIdx"
+      },
+      {
+        "name": "WantApply",
+        "type": "bool"
+      }
+    ],
+    "ImGuiTableSortSpecs": [
+      {
+        "name": "Specs",
+        "type": "const ImGuiTableColumnSortSpecs*"
+      },
+      {
+        "name": "SpecsCount",
+        "type": "int"
+      },
+      {
+        "name": "SpecsDirty",
+        "type": "bool"
+      }
+    ],
+    "ImGuiTableTempData": [
+      {
+        "name": "TableIndex",
+        "type": "int"
+      },
+      {
+        "name": "LastTimeActive",
+        "type": "float"
+      },
+      {
+        "name": "AngledHeadersExtraWidth",
+        "type": "float"
+      },
+      {
+        "name": "AngledHeadersRequests",
+        "template_type": "ImGuiTableHeaderData",
+        "type": "ImVector_ImGuiTableHeaderData"
+      },
+      {
+        "name": "UserOuterSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DrawSplitter",
+        "type": "ImDrawListSplitter"
+      },
+      {
+        "name": "HostBackupWorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "HostBackupParentWorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "HostBackupPrevLineSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "HostBackupCurrLineSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "HostBackupCursorMaxPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "HostBackupColumnsOffset",
+        "type": "ImVec1"
+      },
+      {
+        "name": "HostBackupItemWidth",
+        "type": "float"
+      },
+      {
+        "name": "HostBackupItemWidthStackSize",
+        "type": "int"
+      }
+    ],
+    "ImGuiTextBuffer": [
+      {
+        "name": "Buf",
+        "template_type": "char",
+        "type": "ImVector_char"
+      }
+    ],
+    "ImGuiTextFilter": [
+      {
+        "name": "InputBuf[256]",
+        "size": 256,
+        "type": "char"
+      },
+      {
+        "name": "Filters",
+        "template_type": "ImGuiTextRange",
+        "type": "ImVector_ImGuiTextRange"
+      },
+      {
+        "name": "CountGrep",
+        "type": "int"
+      }
+    ],
+    "ImGuiTextIndex": [
+      {
+        "name": "LineOffsets",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "EndOffset",
+        "type": "int"
+      }
+    ],
+    "ImGuiTextRange": [
+      {
+        "name": "b",
+        "type": "const char*"
+      },
+      {
+        "name": "e",
+        "type": "const char*"
+      }
+    ],
+    "ImGuiTreeNodeStackData": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "TreeFlags",
+        "type": "ImGuiTreeNodeFlags"
+      },
+      {
+        "name": "ItemFlags",
+        "type": "ImGuiItemFlags"
+      },
+      {
+        "name": "NavRect",
+        "type": "ImRect"
+      }
+    ],
+    "ImGuiTypingSelectRequest": [
+      {
+        "name": "Flags",
+        "type": "ImGuiTypingSelectFlags"
+      },
+      {
+        "name": "SearchBufferLen",
+        "type": "int"
+      },
+      {
+        "name": "SearchBuffer",
+        "type": "const char*"
+      },
+      {
+        "name": "SelectRequest",
+        "type": "bool"
+      },
+      {
+        "name": "SingleCharMode",
+        "type": "bool"
+      },
+      {
+        "name": "SingleCharSize",
+        "type": "ImS8"
+      }
+    ],
+    "ImGuiTypingSelectState": [
+      {
+        "name": "Request",
+        "type": "ImGuiTypingSelectRequest"
+      },
+      {
+        "name": "SearchBuffer[64]",
+        "size": 64,
+        "type": "char"
+      },
+      {
+        "name": "FocusScope",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LastRequestFrame",
+        "type": "int"
+      },
+      {
+        "name": "LastRequestTime",
+        "type": "float"
+      },
+      {
+        "name": "SingleCharModeLock",
+        "type": "bool"
+      }
+    ],
+    "ImGuiViewport": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiViewportFlags"
+      },
+      {
+        "name": "Pos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Size",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WorkPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WorkSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "DpiScale",
+        "type": "float"
+      },
+      {
+        "name": "ParentViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DrawData",
+        "type": "ImDrawData*"
+      },
+      {
+        "name": "RendererUserData",
+        "type": "void*"
+      },
+      {
+        "name": "PlatformUserData",
+        "type": "void*"
+      },
+      {
+        "name": "PlatformHandle",
+        "type": "void*"
+      },
+      {
+        "name": "PlatformHandleRaw",
+        "type": "void*"
+      },
+      {
+        "name": "PlatformWindowCreated",
+        "type": "bool"
+      },
+      {
+        "name": "PlatformRequestMove",
+        "type": "bool"
+      },
+      {
+        "name": "PlatformRequestResize",
+        "type": "bool"
+      },
+      {
+        "name": "PlatformRequestClose",
+        "type": "bool"
+      }
+    ],
+    "ImGuiViewportP": [
+      {
+        "name": "_ImGuiViewport",
+        "type": "ImGuiViewport"
+      },
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "Idx",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameActive",
+        "type": "int"
+      },
+      {
+        "name": "LastFocusedStampCount",
+        "type": "int"
+      },
+      {
+        "name": "LastNameHash",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "LastPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LastSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Alpha",
+        "type": "float"
+      },
+      {
+        "name": "LastAlpha",
+        "type": "float"
+      },
+      {
+        "name": "LastFocusedHadNavWindow",
+        "type": "bool"
+      },
+      {
+        "name": "PlatformMonitor",
+        "type": "short"
+      },
+      {
+        "name": "BgFgDrawListsLastFrame[2]",
+        "size": 2,
+        "type": "int"
+      },
+      {
+        "name": "BgFgDrawLists[2]",
+        "size": 2,
+        "type": "ImDrawList*"
+      },
+      {
+        "name": "DrawDataP",
+        "type": "ImDrawData"
+      },
+      {
+        "name": "DrawDataBuilder",
+        "type": "ImDrawDataBuilder"
+      },
+      {
+        "name": "LastPlatformPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LastPlatformSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LastRendererSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WorkInsetMin",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WorkInsetMax",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BuildWorkInsetMin",
+        "type": "ImVec2"
+      },
+      {
+        "name": "BuildWorkInsetMax",
+        "type": "ImVec2"
+      }
+    ],
+    "ImGuiWindow": [
+      {
+        "name": "Ctx",
+        "type": "ImGuiContext*"
+      },
+      {
+        "name": "Name",
+        "type": "char*"
+      },
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImGuiWindowFlags"
+      },
+      {
+        "name": "FlagsPreviousFrame",
+        "type": "ImGuiWindowFlags"
+      },
+      {
+        "name": "ChildFlags",
+        "type": "ImGuiChildFlags"
+      },
+      {
+        "name": "WindowClass",
+        "type": "ImGuiWindowClass"
+      },
+      {
+        "name": "Viewport",
+        "type": "ImGuiViewportP*"
+      },
+      {
+        "name": "ViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ViewportPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ViewportAllowPlatformMonitorExtend",
+        "type": "int"
+      },
+      {
+        "name": "Pos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Size",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SizeFull",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ContentSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ContentSizeIdeal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ContentSizeExplicit",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WindowPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "WindowRounding",
+        "type": "float"
+      },
+      {
+        "name": "WindowBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "TitleBarHeight",
+        "type": "float"
+      },
+      {
+        "name": "MenuBarHeight",
+        "type": "float"
+      },
+      {
+        "name": "DecoOuterSizeX1",
+        "type": "float"
+      },
+      {
+        "name": "DecoOuterSizeY1",
+        "type": "float"
+      },
+      {
+        "name": "DecoOuterSizeX2",
+        "type": "float"
+      },
+      {
+        "name": "DecoOuterSizeY2",
+        "type": "float"
+      },
+      {
+        "name": "DecoInnerSizeX1",
+        "type": "float"
+      },
+      {
+        "name": "DecoInnerSizeY1",
+        "type": "float"
+      },
+      {
+        "name": "NameBufLen",
+        "type": "int"
+      },
+      {
+        "name": "MoveId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "TabId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ChildId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "PopupId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Scroll",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollMax",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollTarget",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollTargetCenterRatio",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollTargetEdgeSnapDist",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollbarSizes",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ScrollbarX",
+        "type": "bool"
+      },
+      {
+        "name": "ScrollbarY",
+        "type": "bool"
+      },
+      {
+        "name": "ViewportOwned",
+        "type": "bool"
+      },
+      {
+        "name": "Active",
+        "type": "bool"
+      },
+      {
+        "name": "WasActive",
+        "type": "bool"
+      },
+      {
+        "name": "WriteAccessed",
+        "type": "bool"
+      },
+      {
+        "name": "Collapsed",
+        "type": "bool"
+      },
+      {
+        "name": "WantCollapseToggle",
+        "type": "bool"
+      },
+      {
+        "name": "SkipItems",
+        "type": "bool"
+      },
+      {
+        "name": "SkipRefresh",
+        "type": "bool"
+      },
+      {
+        "name": "Appearing",
+        "type": "bool"
+      },
+      {
+        "name": "Hidden",
+        "type": "bool"
+      },
+      {
+        "name": "IsFallbackWindow",
+        "type": "bool"
+      },
+      {
+        "name": "IsExplicitChild",
+        "type": "bool"
+      },
+      {
+        "name": "HasCloseButton",
+        "type": "bool"
+      },
+      {
+        "name": "ResizeBorderHovered",
+        "type": "signed char"
+      },
+      {
+        "name": "ResizeBorderHeld",
+        "type": "signed char"
+      },
+      {
+        "name": "BeginCount",
+        "type": "short"
+      },
+      {
+        "name": "BeginCountPreviousFrame",
+        "type": "short"
+      },
+      {
+        "name": "BeginOrderWithinParent",
+        "type": "short"
+      },
+      {
+        "name": "BeginOrderWithinContext",
+        "type": "short"
+      },
+      {
+        "name": "FocusOrder",
+        "type": "short"
+      },
+      {
+        "name": "AutoFitFramesX",
+        "type": "ImS8"
+      },
+      {
+        "name": "AutoFitFramesY",
+        "type": "ImS8"
+      },
+      {
+        "name": "AutoFitOnlyGrows",
+        "type": "bool"
+      },
+      {
+        "name": "AutoPosLastDirection",
+        "type": "ImGuiDir"
+      },
+      {
+        "name": "HiddenFramesCanSkipItems",
+        "type": "ImS8"
+      },
+      {
+        "name": "HiddenFramesCannotSkipItems",
+        "type": "ImS8"
+      },
+      {
+        "name": "HiddenFramesForRenderOnly",
+        "type": "ImS8"
+      },
+      {
+        "name": "DisableInputsFrames",
+        "type": "ImS8"
+      },
+      {
+        "bitfield": "8",
+        "name": "SetWindowPosAllowFlags",
+        "type": "ImGuiCond"
+      },
+      {
+        "bitfield": "8",
+        "name": "SetWindowSizeAllowFlags",
+        "type": "ImGuiCond"
+      },
+      {
+        "bitfield": "8",
+        "name": "SetWindowCollapsedAllowFlags",
+        "type": "ImGuiCond"
+      },
+      {
+        "bitfield": "8",
+        "name": "SetWindowDockAllowFlags",
+        "type": "ImGuiCond"
+      },
+      {
+        "name": "SetWindowPosVal",
+        "type": "ImVec2"
+      },
+      {
+        "name": "SetWindowPosPivot",
+        "type": "ImVec2"
+      },
+      {
+        "name": "IDStack",
+        "template_type": "ImGuiID",
+        "type": "ImVector_ImGuiID"
+      },
+      {
+        "name": "DC",
+        "type": "ImGuiWindowTempData"
+      },
+      {
+        "name": "OuterRectClipped",
+        "type": "ImRect"
+      },
+      {
+        "name": "InnerRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "InnerClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "WorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "ParentWorkRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "ClipRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "ContentRegionRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "HitTestHoleSize",
+        "type": "ImVec2ih"
+      },
+      {
+        "name": "HitTestHoleOffset",
+        "type": "ImVec2ih"
+      },
+      {
+        "name": "LastFrameActive",
+        "type": "int"
+      },
+      {
+        "name": "LastFrameJustFocused",
+        "type": "int"
+      },
+      {
+        "name": "LastTimeActive",
+        "type": "float"
+      },
+      {
+        "name": "ItemWidthDefault",
+        "type": "float"
+      },
+      {
+        "name": "StateStorage",
+        "type": "ImGuiStorage"
+      },
+      {
+        "name": "ColumnsStorage",
+        "template_type": "ImGuiOldColumns",
+        "type": "ImVector_ImGuiOldColumns"
+      },
+      {
+        "name": "FontWindowScale",
+        "type": "float"
+      },
+      {
+        "name": "FontDpiScale",
+        "type": "float"
+      },
+      {
+        "name": "SettingsOffset",
+        "type": "int"
+      },
+      {
+        "name": "DrawList",
+        "type": "ImDrawList*"
+      },
+      {
+        "name": "DrawListInst",
+        "type": "ImDrawList"
+      },
+      {
+        "name": "ParentWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ParentWindowInBeginStack",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "RootWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "RootWindowPopupTree",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "RootWindowDockTree",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "RootWindowForTitleBarHighlight",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "RootWindowForNav",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ParentWindowForFocusRoute",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "NavLastChildNavWindow",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "NavLastIds[ImGuiNavLayer_COUNT]",
+        "size": 2,
+        "type": "ImGuiID"
+      },
+      {
+        "name": "NavRectRel[ImGuiNavLayer_COUNT]",
+        "size": 2,
+        "type": "ImRect"
+      },
+      {
+        "name": "NavPreferredScoringPosRel[ImGuiNavLayer_COUNT]",
+        "size": 2,
+        "type": "ImVec2"
+      },
+      {
+        "name": "NavRootFocusScopeId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "MemoryDrawListIdxCapacity",
+        "type": "int"
+      },
+      {
+        "name": "MemoryDrawListVtxCapacity",
+        "type": "int"
+      },
+      {
+        "name": "MemoryCompacted",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "DockIsActive",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "DockNodeIsVisible",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "DockTabIsVisible",
+        "type": "bool"
+      },
+      {
+        "bitfield": "1",
+        "name": "DockTabWantClose",
+        "type": "bool"
+      },
+      {
+        "name": "DockOrder",
+        "type": "short"
+      },
+      {
+        "name": "DockStyle",
+        "type": "ImGuiWindowDockStyle"
+      },
+      {
+        "name": "DockNode",
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "DockNodeAsHost",
+        "type": "ImGuiDockNode*"
+      },
+      {
+        "name": "DockId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DockTabItemStatusFlags",
+        "type": "ImGuiItemStatusFlags"
+      },
+      {
+        "name": "DockTabItemRect",
+        "type": "ImRect"
+      }
+    ],
+    "ImGuiWindowClass": [
+      {
+        "name": "ClassId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ParentViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "FocusRouteParentWindowId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ViewportFlagsOverrideSet",
+        "type": "ImGuiViewportFlags"
+      },
+      {
+        "name": "ViewportFlagsOverrideClear",
+        "type": "ImGuiViewportFlags"
+      },
+      {
+        "name": "TabItemFlagsOverrideSet",
+        "type": "ImGuiTabItemFlags"
+      },
+      {
+        "name": "DockNodeFlagsOverrideSet",
+        "type": "ImGuiDockNodeFlags"
+      },
+      {
+        "name": "DockingAlwaysTabBar",
+        "type": "bool"
+      },
+      {
+        "name": "DockingAllowUnclassed",
+        "type": "bool"
+      }
+    ],
+    "ImGuiWindowDockStyle": [
+      {
+        "name": "Colors[ImGuiWindowDockStyleCol_COUNT]",
+        "size": 8,
+        "type": "ImU32"
+      }
+    ],
+    "ImGuiWindowSettings": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Pos",
+        "type": "ImVec2ih"
+      },
+      {
+        "name": "Size",
+        "type": "ImVec2ih"
+      },
+      {
+        "name": "ViewportPos",
+        "type": "ImVec2ih"
+      },
+      {
+        "name": "ViewportId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DockId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "ClassId",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "DockOrder",
+        "type": "short"
+      },
+      {
+        "name": "Collapsed",
+        "type": "bool"
+      },
+      {
+        "name": "IsChild",
+        "type": "bool"
+      },
+      {
+        "name": "WantApply",
+        "type": "bool"
+      },
+      {
+        "name": "WantDelete",
+        "type": "bool"
+      }
+    ],
+    "ImGuiWindowStackData": [
+      {
+        "name": "Window",
+        "type": "ImGuiWindow*"
+      },
+      {
+        "name": "ParentLastItemDataBackup",
+        "type": "ImGuiLastItemData"
+      },
+      {
+        "name": "StackSizesInBegin",
+        "type": "ImGuiErrorRecoveryState"
+      },
+      {
+        "name": "DisabledOverrideReenable",
+        "type": "bool"
+      }
+    ],
+    "ImGuiWindowTempData": [
+      {
+        "name": "CursorPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CursorPosPrevLine",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CursorStartPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CursorMaxPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "IdealMaxPos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CurrLineSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "PrevLineSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "CurrLineTextBaseOffset",
+        "type": "float"
+      },
+      {
+        "name": "PrevLineTextBaseOffset",
+        "type": "float"
+      },
+      {
+        "name": "IsSameLine",
+        "type": "bool"
+      },
+      {
+        "name": "IsSetPos",
+        "type": "bool"
+      },
+      {
+        "name": "Indent",
+        "type": "ImVec1"
+      },
+      {
+        "name": "ColumnsOffset",
+        "type": "ImVec1"
+      },
+      {
+        "name": "GroupOffset",
+        "type": "ImVec1"
+      },
+      {
+        "name": "CursorStartPosLossyness",
+        "type": "ImVec2"
+      },
+      {
+        "name": "NavLayerCurrent",
+        "type": "ImGuiNavLayer"
+      },
+      {
+        "name": "NavLayersActiveMask",
+        "type": "short"
+      },
+      {
+        "name": "NavLayersActiveMaskNext",
+        "type": "short"
+      },
+      {
+        "name": "NavIsScrollPushableX",
+        "type": "bool"
+      },
+      {
+        "name": "NavHideHighlightOneFrame",
+        "type": "bool"
+      },
+      {
+        "name": "NavWindowHasScrollY",
+        "type": "bool"
+      },
+      {
+        "name": "MenuBarAppending",
+        "type": "bool"
+      },
+      {
+        "name": "MenuBarOffset",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MenuColumns",
+        "type": "ImGuiMenuColumns"
+      },
+      {
+        "name": "TreeDepth",
+        "type": "int"
+      },
+      {
+        "name": "TreeHasStackDataDepthMask",
+        "type": "ImU32"
+      },
+      {
+        "name": "ChildWindows",
+        "template_type": "ImGuiWindow*",
+        "type": "ImVector_ImGuiWindowPtr"
+      },
+      {
+        "name": "StateStorage",
+        "type": "ImGuiStorage*"
+      },
+      {
+        "name": "CurrentColumns",
+        "type": "ImGuiOldColumns*"
+      },
+      {
+        "name": "CurrentTableIdx",
+        "type": "int"
+      },
+      {
+        "name": "LayoutType",
+        "type": "ImGuiLayoutType"
+      },
+      {
+        "name": "ParentLayoutType",
+        "type": "ImGuiLayoutType"
+      },
+      {
+        "name": "ModalDimBgColor",
+        "type": "ImU32"
+      },
+      {
+        "name": "ItemWidth",
+        "type": "float"
+      },
+      {
+        "name": "TextWrapPos",
+        "type": "float"
+      },
+      {
+        "name": "ItemWidthStack",
+        "template_type": "float",
+        "type": "ImVector_float"
+      },
+      {
+        "name": "TextWrapPosStack",
+        "template_type": "float",
+        "type": "ImVector_float"
+      }
+    ],
+    "ImRect": [
+      {
+        "name": "Min",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Max",
+        "type": "ImVec2"
+      }
+    ],
+    "ImVec1": [
+      {
+        "name": "x",
+        "type": "float"
+      }
+    ],
+    "ImVec2": [
+      {
+        "name": "x",
+        "type": "float"
+      },
+      {
+        "name": "y",
+        "type": "float"
+      }
+    ],
+    "ImVec2ih": [
+      {
+        "name": "x",
+        "type": "short"
+      },
+      {
+        "name": "y",
+        "type": "short"
+      }
+    ],
+    "ImVec4": [
+      {
+        "name": "x",
+        "type": "float"
+      },
+      {
+        "name": "y",
+        "type": "float"
+      },
+      {
+        "name": "z",
+        "type": "float"
+      },
+      {
+        "name": "w",
+        "type": "float"
+      }
+    ]
+  },
+  "templated_structs": {
+    "ImBitArray": [
+      {
+        "name": "Storage[(BITCOUNT+31)>>5]",
+        "type": "ImU32"
+      }
+    ],
+    "ImChunkStream": [
+      {
+        "name": "Buf",
+        "template_type": "char",
+        "type": "ImVector_char"
+      }
+    ],
+    "ImPool": [
+      {
+        "name": "Buf",
+        "type": "ImVector<T>"
+      },
+      {
+        "name": "Map",
+        "type": "ImGuiStorage"
+      },
+      {
+        "name": "FreeIdx",
+        "type": "ImPoolIdx"
+      },
+      {
+        "name": "AliveCount",
+        "type": "ImPoolIdx"
+      }
+    ],
+    "ImSpan": [
+      {
+        "name": "Data",
+        "type": "T*"
+      },
+      {
+        "name": "DataEnd",
+        "type": "T*"
+      }
+    ],
+    "ImSpanAllocator": [
+      {
+        "name": "BasePtr",
+        "type": "char*"
+      },
+      {
+        "name": "CurrOff",
+        "type": "int"
+      },
+      {
+        "name": "CurrIdx",
+        "type": "int"
+      },
+      {
+        "name": "Offsets[CHUNKS]",
+        "type": "int"
+      },
+      {
+        "name": "Sizes[CHUNKS]",
+        "type": "int"
+      }
+    ],
+    "ImVector": [
+      {
+        "name": "Size",
+        "type": "int"
+      },
+      {
+        "name": "Capacity",
+        "type": "int"
+      },
+      {
+        "name": "Data",
+        "type": "T*"
+      }
+    ]
+  },
+  "templates_done": {
+    "ImBitArray": {
+      "ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN": true
+    },
+    "ImChunkStream": {
+      "ImGuiTableSettings": true,
+      "ImGuiWindowSettings": true
+    },
+    "ImPool": {
+      "ImGuiMultiSelectState": true,
+      "ImGuiTabBar": true,
+      "ImGuiTable": true
+    },
+    "ImSpan": {
+      "ImGuiTableCellData": true,
+      "ImGuiTableColumn": true,
+      "ImGuiTableColumnIdx": true
+    },
+    "ImVector": {
+      "ImDrawChannel": true,
+      "ImDrawCmd": true,
+      "ImDrawIdx": true,
+      "ImDrawList*": true,
+      "ImDrawVert": true,
+      "ImFont*": true,
+      "ImFontAtlasCustomRect": true,
+      "ImFontConfig": true,
+      "ImFontGlyph": true,
+      "ImGuiColorMod": true,
+      "ImGuiContextHook": true,
+      "ImGuiDockNodeSettings": true,
+      "ImGuiDockRequest": true,
+      "ImGuiFocusScopeData": true,
+      "ImGuiGroupData": true,
+      "ImGuiID": true,
+      "ImGuiInputEvent": true,
+      "ImGuiItemFlags": true,
+      "ImGuiKeyRoutingData": true,
+      "ImGuiListClipperData": true,
+      "ImGuiListClipperRange": true,
+      "ImGuiMultiSelectState": true,
+      "ImGuiMultiSelectTempData": true,
+      "ImGuiOldColumnData": true,
+      "ImGuiOldColumns": true,
+      "ImGuiPlatformMonitor": true,
+      "ImGuiPopupData": true,
+      "ImGuiPtrOrIndex": true,
+      "ImGuiSelectionRequest": true,
+      "ImGuiSettingsHandler": true,
+      "ImGuiShrinkWidthItem": true,
+      "ImGuiStackLevelInfo": true,
+      "ImGuiStoragePair": true,
+      "ImGuiStyleMod": true,
+      "ImGuiTabBar": true,
+      "ImGuiTabItem": true,
+      "ImGuiTable": true,
+      "ImGuiTableColumnSortSpecs": true,
+      "ImGuiTableHeaderData": true,
+      "ImGuiTableInstanceData": true,
+      "ImGuiTableTempData": true,
+      "ImGuiTextRange": true,
+      "ImGuiTreeNodeStackData": true,
+      "ImGuiViewport*": true,
+      "ImGuiViewportP*": true,
+      "ImGuiWindow*": true,
+      "ImGuiWindowStackData": true,
+      "ImTextureID": true,
+      "ImU32": true,
+      "ImU8": true,
+      "ImVec2": true,
+      "ImVec4": true,
+      "ImWchar": true,
+      "char": true,
+      "const char*": true,
+      "float": true,
+      "int": true,
+      "unsigned char": true
+    }
+  },
+  "typenames": {
+    "ImBitArray": "int BITCOUNT, int OFFSET = 0",
+    "ImChunkStream": "T",
+    "ImPool": "T",
+    "ImSpan": "T",
+    "ImSpanAllocator": "int CHUNKS",
+    "ImVector": "T"
+  }
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimgui/variants.json b/src/CodeGenerator/definitions/cimgui/variants.json
new file mode 100644
index 00000000..8b949008
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimgui/variants.json
@@ -0,0 +1,16 @@
+{
+    "ImFontAtlas_GetTexDataAsAlpha8": [
+        {
+            "name": "out_pixels",
+            "type": "unsigned char**",
+            "variants": [ "IntPtr*" ]
+        }
+    ],
+    "ImFontAtlas_GetTexDataAsRGBA32": [
+        {
+            "name": "out_pixels",
+            "type": "unsigned char**",
+            "variants": [ "IntPtr*" ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimguizmo/definitions.json b/src/CodeGenerator/definitions/cimguizmo/definitions.json
new file mode 100644
index 00000000..c2e5644d
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimguizmo/definitions.json
@@ -0,0 +1,496 @@
+{
+  "ImGuizmo_AllowAxisFlip": [
+    {
+      "args": "(bool value)",
+      "argsT": [
+        {
+          "name": "value",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool value)",
+      "call_args": "(value)",
+      "cimguiname": "ImGuizmo_AllowAxisFlip",
+      "defaults": {},
+      "funcname": "AllowAxisFlip",
+      "location": "ImGuizmo:212",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_AllowAxisFlip",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_BeginFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuizmo_BeginFrame",
+      "defaults": {},
+      "funcname": "BeginFrame",
+      "location": "ImGuizmo:121",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_BeginFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_DecomposeMatrixToComponents": [
+    {
+      "args": "(const float* matrix,float* translation,float* rotation,float* scale)",
+      "argsT": [
+        {
+          "name": "matrix",
+          "type": "const float*"
+        },
+        {
+          "name": "translation",
+          "type": "float*"
+        },
+        {
+          "name": "rotation",
+          "type": "float*"
+        },
+        {
+          "name": "scale",
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(const float* matrix,float* translation,float* rotation,float* scale)",
+      "call_args": "(matrix,translation,rotation,scale)",
+      "cimguiname": "ImGuizmo_DecomposeMatrixToComponents",
+      "defaults": {},
+      "funcname": "DecomposeMatrixToComponents",
+      "location": "ImGuizmo:151",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_DecomposeMatrixToComponents",
+      "ret": "void",
+      "signature": "(const float*,float*,float*,float*)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_DrawCubes": [
+    {
+      "args": "(const float* view,const float* projection,const float* matrices,int matrixCount)",
+      "argsT": [
+        {
+          "name": "view",
+          "type": "const float*"
+        },
+        {
+          "name": "projection",
+          "type": "const float*"
+        },
+        {
+          "name": "matrices",
+          "type": "const float*"
+        },
+        {
+          "name": "matrixCount",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const float* view,const float* projection,const float* matrices,int matrixCount)",
+      "call_args": "(view,projection,matrices,matrixCount)",
+      "cimguiname": "ImGuizmo_DrawCubes",
+      "defaults": {},
+      "funcname": "DrawCubes",
+      "location": "ImGuizmo:159",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_DrawCubes",
+      "ret": "void",
+      "signature": "(const float*,const float*,const float*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_DrawGrid": [
+    {
+      "args": "(const float* view,const float* projection,const float* matrix,const float gridSize)",
+      "argsT": [
+        {
+          "name": "view",
+          "type": "const float*"
+        },
+        {
+          "name": "projection",
+          "type": "const float*"
+        },
+        {
+          "name": "matrix",
+          "type": "const float*"
+        },
+        {
+          "name": "gridSize",
+          "type": "const float"
+        }
+      ],
+      "argsoriginal": "(const float* view,const float* projection,const float* matrix,const float gridSize)",
+      "call_args": "(view,projection,matrix,gridSize)",
+      "cimguiname": "ImGuizmo_DrawGrid",
+      "defaults": {},
+      "funcname": "DrawGrid",
+      "location": "ImGuizmo:160",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_DrawGrid",
+      "ret": "void",
+      "signature": "(const float*,const float*,const float*,const float)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_Enable": [
+    {
+      "args": "(bool enable)",
+      "argsT": [
+        {
+          "name": "enable",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool enable)",
+      "call_args": "(enable)",
+      "cimguiname": "ImGuizmo_Enable",
+      "defaults": {},
+      "funcname": "Enable",
+      "location": "ImGuizmo:137",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_Enable",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_IsOver": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuizmo_IsOver",
+      "defaults": {},
+      "funcname": "IsOver",
+      "location": "ImGuizmo:130",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_IsOverNil",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    },
+    {
+      "args": "(OPERATION op)",
+      "argsT": [
+        {
+          "name": "op",
+          "type": "OPERATION"
+        }
+      ],
+      "argsoriginal": "(OPERATION op)",
+      "call_args": "(op)",
+      "cimguiname": "ImGuizmo_IsOver",
+      "defaults": {},
+      "funcname": "IsOver",
+      "location": "ImGuizmo:206",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_IsOverOPERATION",
+      "ret": "bool",
+      "signature": "(OPERATION)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_IsUsing": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGuizmo_IsUsing",
+      "defaults": {},
+      "funcname": "IsUsing",
+      "location": "ImGuizmo:133",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_IsUsing",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_Manipulate": [
+    {
+      "args": "(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix,const float* snap,const float* localBounds,const float* boundsSnap)",
+      "argsT": [
+        {
+          "name": "view",
+          "type": "const float*"
+        },
+        {
+          "name": "projection",
+          "type": "const float*"
+        },
+        {
+          "name": "operation",
+          "type": "OPERATION"
+        },
+        {
+          "name": "mode",
+          "type": "MODE"
+        },
+        {
+          "name": "matrix",
+          "type": "float*"
+        },
+        {
+          "name": "deltaMatrix",
+          "type": "float*"
+        },
+        {
+          "name": "snap",
+          "type": "const float*"
+        },
+        {
+          "name": "localBounds",
+          "type": "const float*"
+        },
+        {
+          "name": "boundsSnap",
+          "type": "const float*"
+        }
+      ],
+      "argsoriginal": "(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix=NULL,const float* snap=NULL,const float* localBounds=NULL,const float* boundsSnap=NULL)",
+      "call_args": "(view,projection,operation,mode,matrix,deltaMatrix,snap,localBounds,boundsSnap)",
+      "cimguiname": "ImGuizmo_Manipulate",
+      "defaults": {
+        "boundsSnap": "NULL",
+        "deltaMatrix": "NULL",
+        "localBounds": "NULL",
+        "snap": "NULL"
+      },
+      "funcname": "Manipulate",
+      "location": "ImGuizmo:195",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_Manipulate",
+      "ret": "bool",
+      "signature": "(const float*,const float*,OPERATION,MODE,float*,float*,const float*,const float*,const float*)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_RecomposeMatrixFromComponents": [
+    {
+      "args": "(const float* translation,const float* rotation,const float* scale,float* matrix)",
+      "argsT": [
+        {
+          "name": "translation",
+          "type": "const float*"
+        },
+        {
+          "name": "rotation",
+          "type": "const float*"
+        },
+        {
+          "name": "scale",
+          "type": "const float*"
+        },
+        {
+          "name": "matrix",
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(const float* translation,const float* rotation,const float* scale,float* matrix)",
+      "call_args": "(translation,rotation,scale,matrix)",
+      "cimguiname": "ImGuizmo_RecomposeMatrixFromComponents",
+      "defaults": {},
+      "funcname": "RecomposeMatrixFromComponents",
+      "location": "ImGuizmo:152",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_RecomposeMatrixFromComponents",
+      "ret": "void",
+      "signature": "(const float*,const float*,const float*,float*)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_SetDrawlist": [
+    {
+      "args": "(ImDrawList* drawlist)",
+      "argsT": [
+        {
+          "name": "drawlist",
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* drawlist=nullptr)",
+      "call_args": "(drawlist)",
+      "cimguiname": "ImGuizmo_SetDrawlist",
+      "defaults": {
+        "drawlist": "nullptr"
+      },
+      "funcname": "SetDrawlist",
+      "location": "ImGuizmo:118",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_SetDrawlist",
+      "ret": "void",
+      "signature": "(ImDrawList*)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_SetGizmoSizeClipSpace": [
+    {
+      "args": "(float value)",
+      "argsT": [
+        {
+          "name": "value",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float value)",
+      "call_args": "(value)",
+      "cimguiname": "ImGuizmo_SetGizmoSizeClipSpace",
+      "defaults": {},
+      "funcname": "SetGizmoSizeClipSpace",
+      "location": "ImGuizmo:207",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_SetGizmoSizeClipSpace",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_SetID": [
+    {
+      "args": "(int id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int id)",
+      "call_args": "(id)",
+      "cimguiname": "ImGuizmo_SetID",
+      "defaults": {},
+      "funcname": "SetID",
+      "location": "ImGuizmo:203",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_SetID",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_SetImGuiContext": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImGuizmo_SetImGuiContext",
+      "defaults": {},
+      "funcname": "SetImGuiContext",
+      "location": "ImGuizmo:127",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_SetImGuiContext",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_SetOrthographic": [
+    {
+      "args": "(bool isOrthographic)",
+      "argsT": [
+        {
+          "name": "isOrthographic",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool isOrthographic)",
+      "call_args": "(isOrthographic)",
+      "cimguiname": "ImGuizmo_SetOrthographic",
+      "defaults": {},
+      "funcname": "SetOrthographic",
+      "location": "ImGuizmo:156",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_SetOrthographic",
+      "ret": "void",
+      "signature": "(bool)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_SetRect": [
+    {
+      "args": "(float x,float y,float width,float height)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        },
+        {
+          "name": "y",
+          "type": "float"
+        },
+        {
+          "name": "width",
+          "type": "float"
+        },
+        {
+          "name": "height",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x,float y,float width,float height)",
+      "call_args": "(x,y,width,height)",
+      "cimguiname": "ImGuizmo_SetRect",
+      "defaults": {},
+      "funcname": "SetRect",
+      "location": "ImGuizmo:154",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_SetRect",
+      "ret": "void",
+      "signature": "(float,float,float,float)",
+      "stname": ""
+    }
+  ],
+  "ImGuizmo_ViewManipulate": [
+    {
+      "args": "(float* view,float length,ImVec2 position,ImVec2 size,ImU32 backgroundColor)",
+      "argsT": [
+        {
+          "name": "view",
+          "type": "float*"
+        },
+        {
+          "name": "length",
+          "type": "float"
+        },
+        {
+          "name": "position",
+          "type": "ImVec2"
+        },
+        {
+          "name": "size",
+          "type": "ImVec2"
+        },
+        {
+          "name": "backgroundColor",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(float* view,float length,ImVec2 position,ImVec2 size,ImU32 backgroundColor)",
+      "call_args": "(view,length,position,size,backgroundColor)",
+      "cimguiname": "ImGuizmo_ViewManipulate",
+      "defaults": {},
+      "funcname": "ViewManipulate",
+      "location": "ImGuizmo:201",
+      "namespace": "ImGuizmo",
+      "ov_cimguiname": "ImGuizmo_ViewManipulate",
+      "ret": "void",
+      "signature": "(float*,float,ImVec2,ImVec2,ImU32)",
+      "stname": ""
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimguizmo/structs_and_enums.json b/src/CodeGenerator/definitions/cimguizmo/structs_and_enums.json
new file mode 100644
index 00000000..b35bea99
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimguizmo/structs_and_enums.json
@@ -0,0 +1,94 @@
+{
+  "enums": {
+    "MODE": [
+      {
+        "calc_value": 0,
+        "name": "LOCAL",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "WORLD",
+        "value": "1"
+      }
+    ],
+    "OPERATION": [
+      {
+        "calc_value": 1,
+        "name": "TRANSLATE_X",
+        "value": "(1u << 0)"
+      },
+      {
+        "calc_value": 2,
+        "name": "TRANSLATE_Y",
+        "value": "(1u << 1)"
+      },
+      {
+        "calc_value": 4,
+        "name": "TRANSLATE_Z",
+        "value": "(1u << 2)"
+      },
+      {
+        "calc_value": 8,
+        "name": "ROTATE_X",
+        "value": "(1u << 3)"
+      },
+      {
+        "calc_value": 16,
+        "name": "ROTATE_Y",
+        "value": "(1u << 4)"
+      },
+      {
+        "calc_value": 32,
+        "name": "ROTATE_Z",
+        "value": "(1u << 5)"
+      },
+      {
+        "calc_value": 64,
+        "name": "ROTATE_SCREEN",
+        "value": "(1u << 6)"
+      },
+      {
+        "calc_value": 128,
+        "name": "SCALE_X",
+        "value": "(1u << 7)"
+      },
+      {
+        "calc_value": 256,
+        "name": "SCALE_Y",
+        "value": "(1u << 8)"
+      },
+      {
+        "calc_value": 512,
+        "name": "SCALE_Z",
+        "value": "(1u << 9)"
+      },
+      {
+        "calc_value": 1024,
+        "name": "BOUNDS",
+        "value": "(1u << 10)"
+      },
+      {
+        "calc_value": 7,
+        "name": "TRANSLATE",
+        "value": "TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z"
+      },
+      {
+        "calc_value": 120,
+        "name": "ROTATE",
+        "value": "ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN"
+      },
+      {
+        "calc_value": 896,
+        "name": "SCALE",
+        "value": "SCALE_X | SCALE_Y | SCALE_Z"
+      }
+    ]
+  },
+  "enumtypes": [],
+  "locations": {
+    "MODE": "ImGuizmo:189",
+    "OPERATION": "ImGuizmo:166"
+  },
+  "structs": []
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimguizmo/variants.json b/src/CodeGenerator/definitions/cimguizmo/variants.json
new file mode 100644
index 00000000..8593c62d
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimguizmo/variants.json
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimnodes/definitions.json b/src/CodeGenerator/definitions/cimnodes/definitions.json
new file mode 100644
index 00000000..1973a144
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimnodes/definitions.json
@@ -0,0 +1,1599 @@
+{
+  "EmulateThreeButtonMouse_EmulateThreeButtonMouse": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "EmulateThreeButtonMouse_EmulateThreeButtonMouse",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "EmulateThreeButtonMouse",
+      "location": "imnodes:87",
+      "ov_cimguiname": "EmulateThreeButtonMouse_EmulateThreeButtonMouse",
+      "signature": "()",
+      "stname": "EmulateThreeButtonMouse"
+    }
+  ],
+  "EmulateThreeButtonMouse_destroy": [
+    {
+      "args": "(EmulateThreeButtonMouse* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "EmulateThreeButtonMouse*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "EmulateThreeButtonMouse_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "EmulateThreeButtonMouse_destroy",
+      "ret": "void",
+      "signature": "(EmulateThreeButtonMouse*)",
+      "stname": "EmulateThreeButtonMouse"
+    }
+  ],
+  "IO_IO": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "IO_IO",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "IO",
+      "location": "imnodes:109",
+      "ov_cimguiname": "IO_IO",
+      "signature": "()",
+      "stname": "IO"
+    }
+  ],
+  "IO_destroy": [
+    {
+      "args": "(IO* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "IO*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "IO_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "IO_destroy",
+      "ret": "void",
+      "signature": "(IO*)",
+      "stname": "IO"
+    }
+  ],
+  "LinkDetachWithModifierClick_LinkDetachWithModifierClick": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "LinkDetachWithModifierClick_LinkDetachWithModifierClick",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "LinkDetachWithModifierClick",
+      "location": "imnodes:97",
+      "ov_cimguiname": "LinkDetachWithModifierClick_LinkDetachWithModifierClick",
+      "signature": "()",
+      "stname": "LinkDetachWithModifierClick"
+    }
+  ],
+  "LinkDetachWithModifierClick_destroy": [
+    {
+      "args": "(LinkDetachWithModifierClick* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "LinkDetachWithModifierClick*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "LinkDetachWithModifierClick_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "LinkDetachWithModifierClick_destroy",
+      "ret": "void",
+      "signature": "(LinkDetachWithModifierClick*)",
+      "stname": "LinkDetachWithModifierClick"
+    }
+  ],
+  "Style_Style": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "Style_Style",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "Style",
+      "location": "imnodes:149",
+      "ov_cimguiname": "Style_Style",
+      "signature": "()",
+      "stname": "Style"
+    }
+  ],
+  "Style_destroy": [
+    {
+      "args": "(Style* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "Style*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "Style_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "Style_destroy",
+      "ret": "void",
+      "signature": "(Style*)",
+      "stname": "Style"
+    }
+  ],
+  "imnodes_BeginInputAttribute": [
+    {
+      "args": "(int id,PinShape shape)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "shape",
+          "type": "PinShape"
+        }
+      ],
+      "argsoriginal": "(int id,PinShape shape=PinShape_CircleFilled)",
+      "call_args": "(id,shape)",
+      "cimguiname": "imnodes_BeginInputAttribute",
+      "defaults": {
+        "shape": "PinShape_CircleFilled"
+      },
+      "funcname": "BeginInputAttribute",
+      "location": "imnodes:216",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_BeginInputAttribute",
+      "ret": "void",
+      "signature": "(int,PinShape)",
+      "stname": ""
+    }
+  ],
+  "imnodes_BeginNode": [
+    {
+      "args": "(int id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int id)",
+      "call_args": "(id)",
+      "cimguiname": "imnodes_BeginNode",
+      "defaults": {},
+      "funcname": "BeginNode",
+      "location": "imnodes:195",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_BeginNode",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_BeginNodeEditor": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_BeginNodeEditor",
+      "defaults": {},
+      "funcname": "BeginNodeEditor",
+      "location": "imnodes:185",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_BeginNodeEditor",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_BeginNodeTitleBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_BeginNodeTitleBar",
+      "defaults": {},
+      "funcname": "BeginNodeTitleBar",
+      "location": "imnodes:203",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_BeginNodeTitleBar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_BeginOutputAttribute": [
+    {
+      "args": "(int id,PinShape shape)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "shape",
+          "type": "PinShape"
+        }
+      ],
+      "argsoriginal": "(int id,PinShape shape=PinShape_CircleFilled)",
+      "call_args": "(id,shape)",
+      "cimguiname": "imnodes_BeginOutputAttribute",
+      "defaults": {
+        "shape": "PinShape_CircleFilled"
+      },
+      "funcname": "BeginOutputAttribute",
+      "location": "imnodes:219",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_BeginOutputAttribute",
+      "ret": "void",
+      "signature": "(int,PinShape)",
+      "stname": ""
+    }
+  ],
+  "imnodes_BeginStaticAttribute": [
+    {
+      "args": "(int id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int id)",
+      "call_args": "(id)",
+      "cimguiname": "imnodes_BeginStaticAttribute",
+      "defaults": {},
+      "funcname": "BeginStaticAttribute",
+      "location": "imnodes:224",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_BeginStaticAttribute",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_ClearLinkSelection": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_ClearLinkSelection",
+      "defaults": {},
+      "funcname": "ClearLinkSelection",
+      "location": "imnodes:278",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_ClearLinkSelection",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_ClearNodeSelection": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_ClearNodeSelection",
+      "defaults": {},
+      "funcname": "ClearNodeSelection",
+      "location": "imnodes:277",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_ClearNodeSelection",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EditorContextCreate": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EditorContextCreate",
+      "defaults": {},
+      "funcname": "EditorContextCreate",
+      "location": "imnodes:159",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EditorContextCreate",
+      "ret": "EditorContext*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EditorContextFree": [
+    {
+      "args": "(EditorContext* noname1)",
+      "argsT": [
+        {
+          "name": "noname1",
+          "type": "EditorContext*"
+        }
+      ],
+      "argsoriginal": "(EditorContext*)",
+      "call_args": "(noname1)",
+      "cimguiname": "imnodes_EditorContextFree",
+      "defaults": {},
+      "funcname": "EditorContextFree",
+      "location": "imnodes:160",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EditorContextFree",
+      "ret": "void",
+      "signature": "(EditorContext*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_EditorContextGetPanning": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EditorContextGetPanning",
+      "defaults": {},
+      "funcname": "EditorContextGetPanning",
+      "location": "imnodes:162",
+      "namespace": "imnodes",
+      "nonUDT": 1,
+      "ov_cimguiname": "imnodes_EditorContextGetPanning",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EditorContextMoveToNode": [
+    {
+      "args": "(const int node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "const int"
+        }
+      ],
+      "argsoriginal": "(const int node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "imnodes_EditorContextMoveToNode",
+      "defaults": {},
+      "funcname": "EditorContextMoveToNode",
+      "location": "imnodes:164",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EditorContextMoveToNode",
+      "ret": "void",
+      "signature": "(const int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_EditorContextResetPanning": [
+    {
+      "args": "(const ImVec2 pos)",
+      "argsT": [
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos)",
+      "call_args": "(pos)",
+      "cimguiname": "imnodes_EditorContextResetPanning",
+      "defaults": {},
+      "funcname": "EditorContextResetPanning",
+      "location": "imnodes:163",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EditorContextResetPanning",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "imnodes_EditorContextSet": [
+    {
+      "args": "(EditorContext* noname1)",
+      "argsT": [
+        {
+          "name": "noname1",
+          "type": "EditorContext*"
+        }
+      ],
+      "argsoriginal": "(EditorContext*)",
+      "call_args": "(noname1)",
+      "cimguiname": "imnodes_EditorContextSet",
+      "defaults": {},
+      "funcname": "EditorContextSet",
+      "location": "imnodes:161",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EditorContextSet",
+      "ret": "void",
+      "signature": "(EditorContext*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_EndInputAttribute": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EndInputAttribute",
+      "defaults": {},
+      "funcname": "EndInputAttribute",
+      "location": "imnodes:217",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EndInputAttribute",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EndNode": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EndNode",
+      "defaults": {},
+      "funcname": "EndNode",
+      "location": "imnodes:196",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EndNode",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EndNodeEditor": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EndNodeEditor",
+      "defaults": {},
+      "funcname": "EndNodeEditor",
+      "location": "imnodes:186",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EndNodeEditor",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EndNodeTitleBar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EndNodeTitleBar",
+      "defaults": {},
+      "funcname": "EndNodeTitleBar",
+      "location": "imnodes:204",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EndNodeTitleBar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EndOutputAttribute": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EndOutputAttribute",
+      "defaults": {},
+      "funcname": "EndOutputAttribute",
+      "location": "imnodes:220",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EndOutputAttribute",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_EndStaticAttribute": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_EndStaticAttribute",
+      "defaults": {},
+      "funcname": "EndStaticAttribute",
+      "location": "imnodes:225",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_EndStaticAttribute",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetIO": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_GetIO",
+      "defaults": {},
+      "funcname": "GetIO",
+      "location": "imnodes:174",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_GetIO",
+      "ret": "IO*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetNodeDimensions": [
+    {
+      "args": "(ImVec2 *pOut,int id)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int id)",
+      "call_args": "(id)",
+      "cimguiname": "imnodes_GetNodeDimensions",
+      "defaults": {},
+      "funcname": "GetNodeDimensions",
+      "location": "imnodes:198",
+      "namespace": "imnodes",
+      "nonUDT": 1,
+      "ov_cimguiname": "imnodes_GetNodeDimensions",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetNodeEditorSpacePos": [
+    {
+      "args": "(ImVec2 *pOut,const int node_id)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "node_id",
+          "type": "const int"
+        }
+      ],
+      "argsoriginal": "(const int node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "imnodes_GetNodeEditorSpacePos",
+      "defaults": {},
+      "funcname": "GetNodeEditorSpacePos",
+      "location": "imnodes:253",
+      "namespace": "imnodes",
+      "nonUDT": 1,
+      "ov_cimguiname": "imnodes_GetNodeEditorSpacePos",
+      "ret": "void",
+      "signature": "(const int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetNodeGridSpacePos": [
+    {
+      "args": "(ImVec2 *pOut,const int node_id)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "node_id",
+          "type": "const int"
+        }
+      ],
+      "argsoriginal": "(const int node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "imnodes_GetNodeGridSpacePos",
+      "defaults": {},
+      "funcname": "GetNodeGridSpacePos",
+      "location": "imnodes:254",
+      "namespace": "imnodes",
+      "nonUDT": 1,
+      "ov_cimguiname": "imnodes_GetNodeGridSpacePos",
+      "ret": "void",
+      "signature": "(const int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetNodeScreenSpacePos": [
+    {
+      "args": "(ImVec2 *pOut,const int node_id)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "node_id",
+          "type": "const int"
+        }
+      ],
+      "argsoriginal": "(const int node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "imnodes_GetNodeScreenSpacePos",
+      "defaults": {},
+      "funcname": "GetNodeScreenSpacePos",
+      "location": "imnodes:252",
+      "namespace": "imnodes",
+      "nonUDT": 1,
+      "ov_cimguiname": "imnodes_GetNodeScreenSpacePos",
+      "ret": "void",
+      "signature": "(const int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetSelectedLinks": [
+    {
+      "args": "(int* link_ids)",
+      "argsT": [
+        {
+          "name": "link_ids",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* link_ids)",
+      "call_args": "(link_ids)",
+      "cimguiname": "imnodes_GetSelectedLinks",
+      "defaults": {},
+      "funcname": "GetSelectedLinks",
+      "location": "imnodes:274",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_GetSelectedLinks",
+      "ret": "void",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetSelectedNodes": [
+    {
+      "args": "(int* node_ids)",
+      "argsT": [
+        {
+          "name": "node_ids",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* node_ids)",
+      "call_args": "(node_ids)",
+      "cimguiname": "imnodes_GetSelectedNodes",
+      "defaults": {},
+      "funcname": "GetSelectedNodes",
+      "location": "imnodes:273",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_GetSelectedNodes",
+      "ret": "void",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_GetStyle": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_GetStyle",
+      "defaults": {},
+      "funcname": "GetStyle",
+      "location": "imnodes:177",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_GetStyle",
+      "ret": "Style*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_Initialize": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_Initialize",
+      "defaults": {},
+      "funcname": "Initialize",
+      "location": "imnodes:167",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_Initialize",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsAnyAttributeActive": [
+    {
+      "args": "(int* attribute_id)",
+      "argsT": [
+        {
+          "name": "attribute_id",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* attribute_id=((void*)0))",
+      "call_args": "(attribute_id)",
+      "cimguiname": "imnodes_IsAnyAttributeActive",
+      "defaults": {
+        "attribute_id": "((void*)0)"
+      },
+      "funcname": "IsAnyAttributeActive",
+      "location": "imnodes:284",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsAnyAttributeActive",
+      "ret": "bool",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsAttributeActive": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_IsAttributeActive",
+      "defaults": {},
+      "funcname": "IsAttributeActive",
+      "location": "imnodes:282",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsAttributeActive",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsEditorHovered": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_IsEditorHovered",
+      "defaults": {},
+      "funcname": "IsEditorHovered",
+      "location": "imnodes:258",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsEditorHovered",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsLinkCreated": [
+    {
+      "args": "(int* started_at_attribute_id,int* ended_at_attribute_id,bool* created_from_snap)",
+      "argsT": [
+        {
+          "name": "started_at_attribute_id",
+          "type": "int*"
+        },
+        {
+          "name": "ended_at_attribute_id",
+          "type": "int*"
+        },
+        {
+          "name": "created_from_snap",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(int* started_at_attribute_id,int* ended_at_attribute_id,bool* created_from_snap=((void*)0))",
+      "call_args": "(started_at_attribute_id,ended_at_attribute_id,created_from_snap)",
+      "cimguiname": "imnodes_IsLinkCreated",
+      "defaults": {
+        "created_from_snap": "((void*)0)"
+      },
+      "funcname": "IsLinkCreated",
+      "location": "imnodes:299",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsLinkCreatedBoolPtr",
+      "ret": "bool",
+      "signature": "(int*,int*,bool*)",
+      "stname": ""
+    },
+    {
+      "args": "(int* started_at_node_id,int* started_at_attribute_id,int* ended_at_node_id,int* ended_at_attribute_id,bool* created_from_snap)",
+      "argsT": [
+        {
+          "name": "started_at_node_id",
+          "type": "int*"
+        },
+        {
+          "name": "started_at_attribute_id",
+          "type": "int*"
+        },
+        {
+          "name": "ended_at_node_id",
+          "type": "int*"
+        },
+        {
+          "name": "ended_at_attribute_id",
+          "type": "int*"
+        },
+        {
+          "name": "created_from_snap",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(int* started_at_node_id,int* started_at_attribute_id,int* ended_at_node_id,int* ended_at_attribute_id,bool* created_from_snap=((void*)0))",
+      "call_args": "(started_at_node_id,started_at_attribute_id,ended_at_node_id,ended_at_attribute_id,created_from_snap)",
+      "cimguiname": "imnodes_IsLinkCreated",
+      "defaults": {
+        "created_from_snap": "((void*)0)"
+      },
+      "funcname": "IsLinkCreated",
+      "location": "imnodes:303",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsLinkCreatedIntPtr",
+      "ret": "bool",
+      "signature": "(int*,int*,int*,int*,bool*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsLinkDestroyed": [
+    {
+      "args": "(int* link_id)",
+      "argsT": [
+        {
+          "name": "link_id",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* link_id)",
+      "call_args": "(link_id)",
+      "cimguiname": "imnodes_IsLinkDestroyed",
+      "defaults": {},
+      "funcname": "IsLinkDestroyed",
+      "location": "imnodes:312",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsLinkDestroyed",
+      "ret": "bool",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsLinkDropped": [
+    {
+      "args": "(int* started_at_attribute_id,bool including_detached_links)",
+      "argsT": [
+        {
+          "name": "started_at_attribute_id",
+          "type": "int*"
+        },
+        {
+          "name": "including_detached_links",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(int* started_at_attribute_id=((void*)0),bool including_detached_links=true)",
+      "call_args": "(started_at_attribute_id,including_detached_links)",
+      "cimguiname": "imnodes_IsLinkDropped",
+      "defaults": {
+        "including_detached_links": "true",
+        "started_at_attribute_id": "((void*)0)"
+      },
+      "funcname": "IsLinkDropped",
+      "location": "imnodes:297",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsLinkDropped",
+      "ret": "bool",
+      "signature": "(int*,bool)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsLinkHovered": [
+    {
+      "args": "(int* link_id)",
+      "argsT": [
+        {
+          "name": "link_id",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* link_id)",
+      "call_args": "(link_id)",
+      "cimguiname": "imnodes_IsLinkHovered",
+      "defaults": {},
+      "funcname": "IsLinkHovered",
+      "location": "imnodes:263",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsLinkHovered",
+      "ret": "bool",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsLinkStarted": [
+    {
+      "args": "(int* started_at_attribute_id)",
+      "argsT": [
+        {
+          "name": "started_at_attribute_id",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* started_at_attribute_id)",
+      "call_args": "(started_at_attribute_id)",
+      "cimguiname": "imnodes_IsLinkStarted",
+      "defaults": {},
+      "funcname": "IsLinkStarted",
+      "location": "imnodes:290",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsLinkStarted",
+      "ret": "bool",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsNodeHovered": [
+    {
+      "args": "(int* node_id)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* node_id)",
+      "call_args": "(node_id)",
+      "cimguiname": "imnodes_IsNodeHovered",
+      "defaults": {},
+      "funcname": "IsNodeHovered",
+      "location": "imnodes:262",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsNodeHovered",
+      "ret": "bool",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_IsPinHovered": [
+    {
+      "args": "(int* attribute_id)",
+      "argsT": [
+        {
+          "name": "attribute_id",
+          "type": "int*"
+        }
+      ],
+      "argsoriginal": "(int* attribute_id)",
+      "call_args": "(attribute_id)",
+      "cimguiname": "imnodes_IsPinHovered",
+      "defaults": {},
+      "funcname": "IsPinHovered",
+      "location": "imnodes:264",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_IsPinHovered",
+      "ret": "bool",
+      "signature": "(int*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_Link": [
+    {
+      "args": "(int id,int start_attribute_id,int end_attribute_id)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "start_attribute_id",
+          "type": "int"
+        },
+        {
+          "name": "end_attribute_id",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int id,int start_attribute_id,int end_attribute_id)",
+      "call_args": "(id,start_attribute_id,end_attribute_id)",
+      "cimguiname": "imnodes_Link",
+      "defaults": {},
+      "funcname": "Link",
+      "location": "imnodes:234",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_Link",
+      "ret": "void",
+      "signature": "(int,int,int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_LoadCurrentEditorStateFromIniFile": [
+    {
+      "args": "(const char* file_name)",
+      "argsT": [
+        {
+          "name": "file_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* file_name)",
+      "call_args": "(file_name)",
+      "cimguiname": "imnodes_LoadCurrentEditorStateFromIniFile",
+      "defaults": {},
+      "funcname": "LoadCurrentEditorStateFromIniFile",
+      "location": "imnodes:326",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_LoadCurrentEditorStateFromIniFile",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_LoadCurrentEditorStateFromIniString": [
+    {
+      "args": "(const char* data,size_t data_size)",
+      "argsT": [
+        {
+          "name": "data",
+          "type": "const char*"
+        },
+        {
+          "name": "data_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(const char* data,size_t data_size)",
+      "call_args": "(data,data_size)",
+      "cimguiname": "imnodes_LoadCurrentEditorStateFromIniString",
+      "defaults": {},
+      "funcname": "LoadCurrentEditorStateFromIniString",
+      "location": "imnodes:320",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_LoadCurrentEditorStateFromIniString",
+      "ret": "void",
+      "signature": "(const char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "imnodes_LoadEditorStateFromIniFile": [
+    {
+      "args": "(EditorContext* editor,const char* file_name)",
+      "argsT": [
+        {
+          "name": "editor",
+          "type": "EditorContext*"
+        },
+        {
+          "name": "file_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(EditorContext* editor,const char* file_name)",
+      "call_args": "(editor,file_name)",
+      "cimguiname": "imnodes_LoadEditorStateFromIniFile",
+      "defaults": {},
+      "funcname": "LoadEditorStateFromIniFile",
+      "location": "imnodes:327",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_LoadEditorStateFromIniFile",
+      "ret": "void",
+      "signature": "(EditorContext*,const char*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_LoadEditorStateFromIniString": [
+    {
+      "args": "(EditorContext* editor,const char* data,size_t data_size)",
+      "argsT": [
+        {
+          "name": "editor",
+          "type": "EditorContext*"
+        },
+        {
+          "name": "data",
+          "type": "const char*"
+        },
+        {
+          "name": "data_size",
+          "type": "size_t"
+        }
+      ],
+      "argsoriginal": "(EditorContext* editor,const char* data,size_t data_size)",
+      "call_args": "(editor,data,data_size)",
+      "cimguiname": "imnodes_LoadEditorStateFromIniString",
+      "defaults": {},
+      "funcname": "LoadEditorStateFromIniString",
+      "location": "imnodes:321",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_LoadEditorStateFromIniString",
+      "ret": "void",
+      "signature": "(EditorContext*,const char*,size_t)",
+      "stname": ""
+    }
+  ],
+  "imnodes_NumSelectedLinks": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_NumSelectedLinks",
+      "defaults": {},
+      "funcname": "NumSelectedLinks",
+      "location": "imnodes:269",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_NumSelectedLinks",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_NumSelectedNodes": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_NumSelectedNodes",
+      "defaults": {},
+      "funcname": "NumSelectedNodes",
+      "location": "imnodes:268",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_NumSelectedNodes",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_PopAttributeFlag": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_PopAttributeFlag",
+      "defaults": {},
+      "funcname": "PopAttributeFlag",
+      "location": "imnodes:229",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_PopAttributeFlag",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_PopColorStyle": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_PopColorStyle",
+      "defaults": {},
+      "funcname": "PopColorStyle",
+      "location": "imnodes:190",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_PopColorStyle",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_PopStyleVar": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_PopStyleVar",
+      "defaults": {},
+      "funcname": "PopStyleVar",
+      "location": "imnodes:192",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_PopStyleVar",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_PushAttributeFlag": [
+    {
+      "args": "(AttributeFlags flag)",
+      "argsT": [
+        {
+          "name": "flag",
+          "type": "AttributeFlags"
+        }
+      ],
+      "argsoriginal": "(AttributeFlags flag)",
+      "call_args": "(flag)",
+      "cimguiname": "imnodes_PushAttributeFlag",
+      "defaults": {},
+      "funcname": "PushAttributeFlag",
+      "location": "imnodes:228",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_PushAttributeFlag",
+      "ret": "void",
+      "signature": "(AttributeFlags)",
+      "stname": ""
+    }
+  ],
+  "imnodes_PushColorStyle": [
+    {
+      "args": "(ColorStyle item,unsigned int color)",
+      "argsT": [
+        {
+          "name": "item",
+          "type": "ColorStyle"
+        },
+        {
+          "name": "color",
+          "type": "unsigned int"
+        }
+      ],
+      "argsoriginal": "(ColorStyle item,unsigned int color)",
+      "call_args": "(item,color)",
+      "cimguiname": "imnodes_PushColorStyle",
+      "defaults": {},
+      "funcname": "PushColorStyle",
+      "location": "imnodes:189",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_PushColorStyle",
+      "ret": "void",
+      "signature": "(ColorStyle,unsigned int)",
+      "stname": ""
+    }
+  ],
+  "imnodes_PushStyleVar": [
+    {
+      "args": "(StyleVar style_item,float value)",
+      "argsT": [
+        {
+          "name": "style_item",
+          "type": "StyleVar"
+        },
+        {
+          "name": "value",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(StyleVar style_item,float value)",
+      "call_args": "(style_item,value)",
+      "cimguiname": "imnodes_PushStyleVar",
+      "defaults": {},
+      "funcname": "PushStyleVar",
+      "location": "imnodes:191",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_PushStyleVar",
+      "ret": "void",
+      "signature": "(StyleVar,float)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SaveCurrentEditorStateToIniFile": [
+    {
+      "args": "(const char* file_name)",
+      "argsT": [
+        {
+          "name": "file_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* file_name)",
+      "call_args": "(file_name)",
+      "cimguiname": "imnodes_SaveCurrentEditorStateToIniFile",
+      "defaults": {},
+      "funcname": "SaveCurrentEditorStateToIniFile",
+      "location": "imnodes:323",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SaveCurrentEditorStateToIniFile",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SaveCurrentEditorStateToIniString": [
+    {
+      "args": "(size_t* data_size)",
+      "argsT": [
+        {
+          "name": "data_size",
+          "type": "size_t*"
+        }
+      ],
+      "argsoriginal": "(size_t* data_size=((void*)0))",
+      "call_args": "(data_size)",
+      "cimguiname": "imnodes_SaveCurrentEditorStateToIniString",
+      "defaults": {
+        "data_size": "((void*)0)"
+      },
+      "funcname": "SaveCurrentEditorStateToIniString",
+      "location": "imnodes:317",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SaveCurrentEditorStateToIniString",
+      "ret": "const char*",
+      "signature": "(size_t*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SaveEditorStateToIniFile": [
+    {
+      "args": "(const EditorContext* editor,const char* file_name)",
+      "argsT": [
+        {
+          "name": "editor",
+          "type": "const EditorContext*"
+        },
+        {
+          "name": "file_name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const EditorContext* editor,const char* file_name)",
+      "call_args": "(editor,file_name)",
+      "cimguiname": "imnodes_SaveEditorStateToIniFile",
+      "defaults": {},
+      "funcname": "SaveEditorStateToIniFile",
+      "location": "imnodes:324",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SaveEditorStateToIniFile",
+      "ret": "void",
+      "signature": "(const EditorContext*,const char*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SaveEditorStateToIniString": [
+    {
+      "args": "(const EditorContext* editor,size_t* data_size)",
+      "argsT": [
+        {
+          "name": "editor",
+          "type": "const EditorContext*"
+        },
+        {
+          "name": "data_size",
+          "type": "size_t*"
+        }
+      ],
+      "argsoriginal": "(const EditorContext* editor,size_t* data_size=((void*)0))",
+      "call_args": "(editor,data_size)",
+      "cimguiname": "imnodes_SaveEditorStateToIniString",
+      "defaults": {
+        "data_size": "((void*)0)"
+      },
+      "funcname": "SaveEditorStateToIniString",
+      "location": "imnodes:318",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SaveEditorStateToIniString",
+      "ret": "const char*",
+      "signature": "(const EditorContext*,size_t*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SetImGuiContext": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "imnodes_SetImGuiContext",
+      "defaults": {},
+      "funcname": "SetImGuiContext",
+      "location": "imnodes:172",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SetImGuiContext",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SetNodeDraggable": [
+    {
+      "args": "(int node_id,const bool draggable)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "int"
+        },
+        {
+          "name": "draggable",
+          "type": "const bool"
+        }
+      ],
+      "argsoriginal": "(int node_id,const bool draggable)",
+      "call_args": "(node_id,draggable)",
+      "cimguiname": "imnodes_SetNodeDraggable",
+      "defaults": {},
+      "funcname": "SetNodeDraggable",
+      "location": "imnodes:237",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SetNodeDraggable",
+      "ret": "void",
+      "signature": "(int,const bool)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SetNodeEditorSpacePos": [
+    {
+      "args": "(int node_id,const ImVec2 editor_space_pos)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "int"
+        },
+        {
+          "name": "editor_space_pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(int node_id,const ImVec2& editor_space_pos)",
+      "call_args": "(node_id,editor_space_pos)",
+      "cimguiname": "imnodes_SetNodeEditorSpacePos",
+      "defaults": {},
+      "funcname": "SetNodeEditorSpacePos",
+      "location": "imnodes:249",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SetNodeEditorSpacePos",
+      "ret": "void",
+      "signature": "(int,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SetNodeGridSpacePos": [
+    {
+      "args": "(int node_id,const ImVec2 grid_pos)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "int"
+        },
+        {
+          "name": "grid_pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(int node_id,const ImVec2& grid_pos)",
+      "call_args": "(node_id,grid_pos)",
+      "cimguiname": "imnodes_SetNodeGridSpacePos",
+      "defaults": {},
+      "funcname": "SetNodeGridSpacePos",
+      "location": "imnodes:250",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SetNodeGridSpacePos",
+      "ret": "void",
+      "signature": "(int,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "imnodes_SetNodeScreenSpacePos": [
+    {
+      "args": "(int node_id,const ImVec2 screen_space_pos)",
+      "argsT": [
+        {
+          "name": "node_id",
+          "type": "int"
+        },
+        {
+          "name": "screen_space_pos",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(int node_id,const ImVec2& screen_space_pos)",
+      "call_args": "(node_id,screen_space_pos)",
+      "cimguiname": "imnodes_SetNodeScreenSpacePos",
+      "defaults": {},
+      "funcname": "SetNodeScreenSpacePos",
+      "location": "imnodes:248",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_SetNodeScreenSpacePos",
+      "ret": "void",
+      "signature": "(int,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "imnodes_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_Shutdown",
+      "defaults": {},
+      "funcname": "Shutdown",
+      "location": "imnodes:168",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_Shutdown",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_StyleColorsClassic": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_StyleColorsClassic",
+      "defaults": {},
+      "funcname": "StyleColorsClassic",
+      "location": "imnodes:180",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_StyleColorsClassic",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_StyleColorsDark": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_StyleColorsDark",
+      "defaults": {},
+      "funcname": "StyleColorsDark",
+      "location": "imnodes:179",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_StyleColorsDark",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "imnodes_StyleColorsLight": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "imnodes_StyleColorsLight",
+      "defaults": {},
+      "funcname": "StyleColorsLight",
+      "location": "imnodes:181",
+      "namespace": "imnodes",
+      "ov_cimguiname": "imnodes_StyleColorsLight",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimnodes/structs_and_enums.json b/src/CodeGenerator/definitions/cimnodes/structs_and_enums.json
new file mode 100644
index 00000000..9588c28f
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimnodes/structs_and_enums.json
@@ -0,0 +1,336 @@
+{
+  "enums": {
+    "AttributeFlags": [
+      {
+        "calc_value": 0,
+        "name": "AttributeFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "AttributeFlags_EnableLinkDetachWithDragClick",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "AttributeFlags_EnableLinkCreationOnSnap",
+        "value": "1 << 1"
+      }
+    ],
+    "ColorStyle": [
+      {
+        "calc_value": 0,
+        "name": "ColorStyle_NodeBackground",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ColorStyle_NodeBackgroundHovered",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ColorStyle_NodeBackgroundSelected",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ColorStyle_NodeOutline",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ColorStyle_TitleBar",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ColorStyle_TitleBarHovered",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ColorStyle_TitleBarSelected",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ColorStyle_Link",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ColorStyle_LinkHovered",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ColorStyle_LinkSelected",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ColorStyle_Pin",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ColorStyle_PinHovered",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ColorStyle_BoxSelector",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ColorStyle_BoxSelectorOutline",
+        "value": "13"
+      },
+      {
+        "calc_value": 14,
+        "name": "ColorStyle_GridBackground",
+        "value": "14"
+      },
+      {
+        "calc_value": 15,
+        "name": "ColorStyle_GridLine",
+        "value": "15"
+      },
+      {
+        "calc_value": 16,
+        "name": "ColorStyle_Count",
+        "value": "16"
+      }
+    ],
+    "PinShape": [
+      {
+        "calc_value": 0,
+        "name": "PinShape_Circle",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "PinShape_CircleFilled",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "PinShape_Triangle",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "PinShape_TriangleFilled",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "PinShape_Quad",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "PinShape_QuadFilled",
+        "value": "5"
+      }
+    ],
+    "StyleFlags": [
+      {
+        "calc_value": 0,
+        "name": "StyleFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "StyleFlags_NodeOutline",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 4,
+        "name": "StyleFlags_GridLines",
+        "value": "1 << 2"
+      }
+    ],
+    "StyleVar": [
+      {
+        "calc_value": 0,
+        "name": "StyleVar_GridSpacing",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "StyleVar_NodeCornerRounding",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "StyleVar_NodePaddingHorizontal",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "StyleVar_NodePaddingVertical",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "StyleVar_NodeBorderThickness",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "StyleVar_LinkThickness",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "StyleVar_LinkLineSegmentsPerLength",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "StyleVar_LinkHoverDistance",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "StyleVar_PinCircleRadius",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "StyleVar_PinQuadSideLength",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "StyleVar_PinTriangleSideLength",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "StyleVar_PinLineThickness",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "StyleVar_PinHoverRadius",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "StyleVar_PinOffset",
+        "value": "13"
+      }
+    ]
+  },
+  "enumtypes": [],
+  "locations": {
+    "AttributeFlags": "imnodes:68",
+    "ColorStyle": "imnodes:10",
+    "EmulateThreeButtonMouse": "imnodes:85",
+    "IO": "imnodes:83",
+    "LinkDetachWithModifierClick": "imnodes:95",
+    "PinShape": "imnodes:57",
+    "Style": "imnodes:112",
+    "StyleFlags": "imnodes:49",
+    "StyleVar": "imnodes:31"
+  },
+  "structs": {
+    "EmulateThreeButtonMouse": [
+      {
+        "name": "enabled",
+        "type": "bool"
+      },
+      {
+        "name": "modifier",
+        "type": "const bool*"
+      }
+    ],
+    "IO": [
+      {
+        "name": "emulate_three_button_mouse",
+        "type": "EmulateThreeButtonMouse"
+      },
+      {
+        "name": "link_detach_with_modifier_click",
+        "type": "LinkDetachWithModifierClick"
+      }
+    ],
+    "LinkDetachWithModifierClick": [
+      {
+        "name": "modifier",
+        "type": "const bool*"
+      }
+    ],
+    "Style": [
+      {
+        "name": "grid_spacing",
+        "type": "float"
+      },
+      {
+        "name": "node_corner_rounding",
+        "type": "float"
+      },
+      {
+        "name": "node_padding_horizontal",
+        "type": "float"
+      },
+      {
+        "name": "node_padding_vertical",
+        "type": "float"
+      },
+      {
+        "name": "node_border_thickness",
+        "type": "float"
+      },
+      {
+        "name": "link_thickness",
+        "type": "float"
+      },
+      {
+        "name": "link_line_segments_per_length",
+        "type": "float"
+      },
+      {
+        "name": "link_hover_distance",
+        "type": "float"
+      },
+      {
+        "name": "pin_circle_radius",
+        "type": "float"
+      },
+      {
+        "name": "pin_quad_side_length",
+        "type": "float"
+      },
+      {
+        "name": "pin_triangle_side_length",
+        "type": "float"
+      },
+      {
+        "name": "pin_line_thickness",
+        "type": "float"
+      },
+      {
+        "name": "pin_hover_radius",
+        "type": "float"
+      },
+      {
+        "name": "pin_offset",
+        "type": "float"
+      },
+      {
+        "name": "flags",
+        "type": "StyleFlags"
+      },
+      {
+        "name": "colors[ColorStyle_Count]",
+        "size": 16,
+        "type": "unsigned int"
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimnodes/variants.json b/src/CodeGenerator/definitions/cimnodes/variants.json
new file mode 100644
index 00000000..8593c62d
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimnodes/variants.json
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimplot/definitions.json b/src/CodeGenerator/definitions/cimplot/definitions.json
new file mode 100644
index 00000000..fefc8b6b
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimplot/definitions.json
@@ -0,0 +1,25176 @@
+{
+  "ImPlotAlignmentData_Begin": [
+    {
+      "args": "(ImPlotAlignmentData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAlignmentData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAlignmentData_Begin",
+      "defaults": {},
+      "funcname": "Begin",
+      "location": "implot_internal:930",
+      "ov_cimguiname": "ImPlotAlignmentData_Begin",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAlignmentData"
+    }
+  ],
+  "ImPlotAlignmentData_End": [
+    {
+      "args": "(ImPlotAlignmentData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAlignmentData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAlignmentData_End",
+      "defaults": {},
+      "funcname": "End",
+      "location": "implot_internal:938",
+      "ov_cimguiname": "ImPlotAlignmentData_End",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAlignmentData"
+    }
+  ],
+  "ImPlotAlignmentData_ImPlotAlignmentData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAlignmentData_ImPlotAlignmentData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotAlignmentData",
+      "location": "implot_internal:926",
+      "ov_cimguiname": "ImPlotAlignmentData_ImPlotAlignmentData",
+      "signature": "()",
+      "stname": "ImPlotAlignmentData"
+    }
+  ],
+  "ImPlotAlignmentData_Reset": [
+    {
+      "args": "(ImPlotAlignmentData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAlignmentData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAlignmentData_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:939",
+      "ov_cimguiname": "ImPlotAlignmentData_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAlignmentData"
+    }
+  ],
+  "ImPlotAlignmentData_Update": [
+    {
+      "args": "(ImPlotAlignmentData* self,float* pad_a,float* pad_b,float* delta_a,float* delta_b)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAlignmentData*"
+        },
+        {
+          "name": "pad_a",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "pad_b",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "delta_a",
+          "reftoptr": true,
+          "type": "float*"
+        },
+        {
+          "name": "delta_b",
+          "reftoptr": true,
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(float& pad_a,float& pad_b,float& delta_a,float& delta_b)",
+      "call_args": "(*pad_a,*pad_b,*delta_a,*delta_b)",
+      "cimguiname": "ImPlotAlignmentData_Update",
+      "defaults": {},
+      "funcname": "Update",
+      "location": "implot_internal:931",
+      "ov_cimguiname": "ImPlotAlignmentData_Update",
+      "ret": "void",
+      "signature": "(float*,float*,float*,float*)",
+      "stname": "ImPlotAlignmentData"
+    }
+  ],
+  "ImPlotAlignmentData_destroy": [
+    {
+      "args": "(ImPlotAlignmentData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAlignmentData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotAlignmentData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotAlignmentData_destroy",
+      "ret": "void",
+      "signature": "(ImPlotAlignmentData*)",
+      "stname": "ImPlotAlignmentData"
+    }
+  ],
+  "ImPlotAnnotationCollection_Append": [
+    {
+      "args": "(ImPlotAnnotationCollection* self,const ImVec2 pos,const ImVec2 off,ImU32 bg,ImU32 fg,bool clamp,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAnnotationCollection*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "off",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "bg",
+          "type": "ImU32"
+        },
+        {
+          "name": "fg",
+          "type": "ImU32"
+        },
+        {
+          "name": "clamp",
+          "type": "bool"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,const ImVec2& off,ImU32 bg,ImU32 fg,bool clamp,const char* fmt,...)",
+      "call_args": "(pos,off,bg,fg,clamp,fmt,...)",
+      "cimguiname": "ImPlotAnnotationCollection_Append",
+      "defaults": {},
+      "funcname": "Append",
+      "isvararg": "...)",
+      "location": "implot_internal:469",
+      "ov_cimguiname": "ImPlotAnnotationCollection_Append",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,ImU32,bool,const char*,...)",
+      "stname": "ImPlotAnnotationCollection"
+    }
+  ],
+  "ImPlotAnnotationCollection_AppendV": [
+    {
+      "args": "(ImPlotAnnotationCollection* self,const ImVec2 pos,const ImVec2 off,ImU32 bg,ImU32 fg,bool clamp,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAnnotationCollection*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "off",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "bg",
+          "type": "ImU32"
+        },
+        {
+          "name": "fg",
+          "type": "ImU32"
+        },
+        {
+          "name": "clamp",
+          "type": "bool"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pos,const ImVec2& off,ImU32 bg,ImU32 fg,bool clamp,const char* fmt,va_list args)",
+      "call_args": "(pos,off,bg,fg,clamp,fmt,args)",
+      "cimguiname": "ImPlotAnnotationCollection_AppendV",
+      "defaults": {},
+      "funcname": "AppendV",
+      "location": "implot_internal:456",
+      "ov_cimguiname": "ImPlotAnnotationCollection_AppendV",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,ImU32,ImU32,bool,const char*,va_list)",
+      "stname": "ImPlotAnnotationCollection"
+    }
+  ],
+  "ImPlotAnnotationCollection_GetText": [
+    {
+      "args": "(ImPlotAnnotationCollection* self,int idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAnnotationCollection*"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlotAnnotationCollection_GetText",
+      "defaults": {},
+      "funcname": "GetText",
+      "location": "implot_internal:476",
+      "ov_cimguiname": "ImPlotAnnotationCollection_GetText",
+      "ret": "const char*",
+      "signature": "(int)",
+      "stname": "ImPlotAnnotationCollection"
+    }
+  ],
+  "ImPlotAnnotationCollection_ImPlotAnnotationCollection": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAnnotationCollection_ImPlotAnnotationCollection",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotAnnotationCollection",
+      "location": "implot_internal:454",
+      "ov_cimguiname": "ImPlotAnnotationCollection_ImPlotAnnotationCollection",
+      "signature": "()",
+      "stname": "ImPlotAnnotationCollection"
+    }
+  ],
+  "ImPlotAnnotationCollection_Reset": [
+    {
+      "args": "(ImPlotAnnotationCollection* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAnnotationCollection*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAnnotationCollection_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:480",
+      "ov_cimguiname": "ImPlotAnnotationCollection_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAnnotationCollection"
+    }
+  ],
+  "ImPlotAnnotationCollection_destroy": [
+    {
+      "args": "(ImPlotAnnotationCollection* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAnnotationCollection*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotAnnotationCollection_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotAnnotationCollection_destroy",
+      "ret": "void",
+      "signature": "(ImPlotAnnotationCollection*)",
+      "stname": "ImPlotAnnotationCollection"
+    }
+  ],
+  "ImPlotAnnotation_ImPlotAnnotation": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAnnotation_ImPlotAnnotation",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotAnnotation",
+      "location": "implot_internal:440",
+      "ov_cimguiname": "ImPlotAnnotation_ImPlotAnnotation",
+      "signature": "()",
+      "stname": "ImPlotAnnotation"
+    }
+  ],
+  "ImPlotAnnotation_destroy": [
+    {
+      "args": "(ImPlotAnnotation* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAnnotation*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotAnnotation_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotAnnotation_destroy",
+      "ret": "void",
+      "signature": "(ImPlotAnnotation*)",
+      "stname": "ImPlotAnnotation"
+    }
+  ],
+  "ImPlotAxis_ApplyFit": [
+    {
+      "args": "(ImPlotAxis* self,float padding)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "padding",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float padding)",
+      "call_args": "(padding)",
+      "cimguiname": "ImPlotAxis_ApplyFit",
+      "defaults": {},
+      "funcname": "ApplyFit",
+      "location": "implot_internal:859",
+      "ov_cimguiname": "ImPlotAxis_ApplyFit",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_CanInitFit": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_CanInitFit",
+      "defaults": {},
+      "funcname": "CanInitFit",
+      "location": "implot_internal:884",
+      "ov_cimguiname": "ImPlotAxis_CanInitFit",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_Constrain": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_Constrain",
+      "defaults": {},
+      "funcname": "Constrain",
+      "location": "implot_internal:789",
+      "ov_cimguiname": "ImPlotAxis_Constrain",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_ExtendFit": [
+    {
+      "args": "(ImPlotAxis* self,double v)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "v",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double v)",
+      "call_args": "(v)",
+      "cimguiname": "ImPlotAxis_ExtendFit",
+      "defaults": {},
+      "funcname": "ExtendFit",
+      "location": "implot_internal:843",
+      "ov_cimguiname": "ImPlotAxis_ExtendFit",
+      "ret": "void",
+      "signature": "(double)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_ExtendFitWith": [
+    {
+      "args": "(ImPlotAxis* self,ImPlotAxis* alt,double v,double v_alt)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "alt",
+          "reftoptr": true,
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "v_alt",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis& alt,double v,double v_alt)",
+      "call_args": "(*alt,v,v_alt)",
+      "cimguiname": "ImPlotAxis_ExtendFitWith",
+      "defaults": {},
+      "funcname": "ExtendFitWith",
+      "location": "implot_internal:850",
+      "ov_cimguiname": "ImPlotAxis_ExtendFitWith",
+      "ret": "void",
+      "signature": "(ImPlotAxis*,double,double)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_GetAspect": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_GetAspect",
+      "defaults": {},
+      "funcname": "GetAspect",
+      "location": "implot_internal:787",
+      "ov_cimguiname": "ImPlotAxis_GetAspect",
+      "ret": "double",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_HasGridLines": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_HasGridLines",
+      "defaults": {},
+      "funcname": "HasGridLines",
+      "location": "implot_internal:876",
+      "ov_cimguiname": "ImPlotAxis_HasGridLines",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_HasLabel": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_HasLabel",
+      "defaults": {},
+      "funcname": "HasLabel",
+      "location": "implot_internal:875",
+      "ov_cimguiname": "ImPlotAxis_HasLabel",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_HasMenus": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_HasMenus",
+      "defaults": {},
+      "funcname": "HasMenus",
+      "location": "implot_internal:892",
+      "ov_cimguiname": "ImPlotAxis_HasMenus",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_HasTickLabels": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_HasTickLabels",
+      "defaults": {},
+      "funcname": "HasTickLabels",
+      "location": "implot_internal:877",
+      "ov_cimguiname": "ImPlotAxis_HasTickLabels",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_HasTickMarks": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_HasTickMarks",
+      "defaults": {},
+      "funcname": "HasTickMarks",
+      "location": "implot_internal:878",
+      "ov_cimguiname": "ImPlotAxis_HasTickMarks",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_ImPlotAxis": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_ImPlotAxis",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotAxis",
+      "location": "implot_internal:674",
+      "ov_cimguiname": "ImPlotAxis_ImPlotAxis",
+      "signature": "()",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsAutoFitting": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsAutoFitting",
+      "defaults": {},
+      "funcname": "IsAutoFitting",
+      "location": "implot_internal:883",
+      "ov_cimguiname": "ImPlotAxis_IsAutoFitting",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsForeground": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsForeground",
+      "defaults": {},
+      "funcname": "IsForeground",
+      "location": "implot_internal:882",
+      "ov_cimguiname": "ImPlotAxis_IsForeground",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsInputLocked": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsInputLocked",
+      "defaults": {},
+      "funcname": "IsInputLocked",
+      "location": "implot_internal:891",
+      "ov_cimguiname": "ImPlotAxis_IsInputLocked",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsInputLockedMax": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsInputLockedMax",
+      "defaults": {},
+      "funcname": "IsInputLockedMax",
+      "location": "implot_internal:890",
+      "ov_cimguiname": "ImPlotAxis_IsInputLockedMax",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsInputLockedMin": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsInputLockedMin",
+      "defaults": {},
+      "funcname": "IsInputLockedMin",
+      "location": "implot_internal:889",
+      "ov_cimguiname": "ImPlotAxis_IsInputLockedMin",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsInverted": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsInverted",
+      "defaults": {},
+      "funcname": "IsInverted",
+      "location": "implot_internal:881",
+      "ov_cimguiname": "ImPlotAxis_IsInverted",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsLocked": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsLocked",
+      "defaults": {},
+      "funcname": "IsLocked",
+      "location": "implot_internal:888",
+      "ov_cimguiname": "ImPlotAxis_IsLocked",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsLockedMax": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsLockedMax",
+      "defaults": {},
+      "funcname": "IsLockedMax",
+      "location": "implot_internal:887",
+      "ov_cimguiname": "ImPlotAxis_IsLockedMax",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsLockedMin": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsLockedMin",
+      "defaults": {},
+      "funcname": "IsLockedMin",
+      "location": "implot_internal:886",
+      "ov_cimguiname": "ImPlotAxis_IsLockedMin",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsOpposite": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsOpposite",
+      "defaults": {},
+      "funcname": "IsOpposite",
+      "location": "implot_internal:880",
+      "ov_cimguiname": "ImPlotAxis_IsOpposite",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsPanLocked": [
+    {
+      "args": "(ImPlotAxis* self,bool increasing)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "increasing",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(bool increasing)",
+      "call_args": "(increasing)",
+      "cimguiname": "ImPlotAxis_IsPanLocked",
+      "defaults": {},
+      "funcname": "IsPanLocked",
+      "location": "implot_internal:894",
+      "ov_cimguiname": "ImPlotAxis_IsPanLocked",
+      "ret": "bool",
+      "signature": "(bool)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_IsRangeLocked": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_IsRangeLocked",
+      "defaults": {},
+      "funcname": "IsRangeLocked",
+      "location": "implot_internal:885",
+      "ov_cimguiname": "ImPlotAxis_IsRangeLocked",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_PixelSize": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_PixelSize",
+      "defaults": {},
+      "funcname": "PixelSize",
+      "location": "implot_internal:785",
+      "ov_cimguiname": "ImPlotAxis_PixelSize",
+      "ret": "float",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_PixelsToPlot": [
+    {
+      "args": "(ImPlotAxis* self,float pix)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "pix",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float pix)",
+      "call_args": "(pix)",
+      "cimguiname": "ImPlotAxis_PixelsToPlot",
+      "defaults": {},
+      "funcname": "PixelsToPlot",
+      "location": "implot_internal:833",
+      "ov_cimguiname": "ImPlotAxis_PixelsToPlot",
+      "ret": "double",
+      "signature": "(float)const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_PlotToPixels": [
+    {
+      "args": "(ImPlotAxis* self,double plt)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "plt",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double plt)",
+      "call_args": "(plt)",
+      "cimguiname": "ImPlotAxis_PlotToPixels",
+      "defaults": {},
+      "funcname": "PlotToPixels",
+      "location": "implot_internal:823",
+      "ov_cimguiname": "ImPlotAxis_PlotToPixels",
+      "ret": "float",
+      "signature": "(double)const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_PullLinks": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_PullLinks",
+      "defaults": {},
+      "funcname": "PullLinks",
+      "location": "implot_internal:913",
+      "ov_cimguiname": "ImPlotAxis_PullLinks",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_PushLinks": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_PushLinks",
+      "defaults": {},
+      "funcname": "PushLinks",
+      "location": "implot_internal:908",
+      "ov_cimguiname": "ImPlotAxis_PushLinks",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_Reset": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:701",
+      "ov_cimguiname": "ImPlotAxis_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_SetAspect": [
+    {
+      "args": "(ImPlotAxis* self,double unit_per_pix)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "unit_per_pix",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double unit_per_pix)",
+      "call_args": "(unit_per_pix)",
+      "cimguiname": "ImPlotAxis_SetAspect",
+      "defaults": {},
+      "funcname": "SetAspect",
+      "location": "implot_internal:772",
+      "ov_cimguiname": "ImPlotAxis_SetAspect",
+      "ret": "void",
+      "signature": "(double)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_SetMax": [
+    {
+      "args": "(ImPlotAxis* self,double _max,bool force)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "_max",
+          "type": "double"
+        },
+        {
+          "name": "force",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double _max,bool force=false)",
+      "call_args": "(_max,force)",
+      "cimguiname": "ImPlotAxis_SetMax",
+      "defaults": {
+        "force": "false"
+      },
+      "funcname": "SetMax",
+      "location": "implot_internal:740",
+      "ov_cimguiname": "ImPlotAxis_SetMax",
+      "ret": "bool",
+      "signature": "(double,bool)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_SetMin": [
+    {
+      "args": "(ImPlotAxis* self,double _min,bool force)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "_min",
+          "type": "double"
+        },
+        {
+          "name": "force",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double _min,bool force=false)",
+      "call_args": "(_min,force)",
+      "cimguiname": "ImPlotAxis_SetMin",
+      "defaults": {
+        "force": "false"
+      },
+      "funcname": "SetMin",
+      "location": "implot_internal:721",
+      "ov_cimguiname": "ImPlotAxis_SetMin",
+      "ret": "bool",
+      "signature": "(double,bool)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_SetRange": [
+    {
+      "args": "(ImPlotAxis* self,double v1,double v2)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "v1",
+          "type": "double"
+        },
+        {
+          "name": "v2",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double v1,double v2)",
+      "call_args": "(v1,v2)",
+      "cimguiname": "ImPlotAxis_SetRange",
+      "defaults": {},
+      "funcname": "SetRange",
+      "location": "implot_internal:759",
+      "ov_cimguiname": "ImPlotAxis_SetRange_double",
+      "ret": "void",
+      "signature": "(double,double)",
+      "stname": "ImPlotAxis"
+    },
+    {
+      "args": "(ImPlotAxis* self,const ImPlotRange range)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        }
+      ],
+      "argsoriginal": "(const ImPlotRange& range)",
+      "call_args": "(range)",
+      "cimguiname": "ImPlotAxis_SetRange",
+      "defaults": {},
+      "funcname": "SetRange",
+      "location": "implot_internal:768",
+      "ov_cimguiname": "ImPlotAxis_SetRange_PlotRange",
+      "ret": "void",
+      "signature": "(const ImPlotRange)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_UpdateTransformCache": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_UpdateTransformCache",
+      "defaults": {},
+      "funcname": "UpdateTransformCache",
+      "location": "implot_internal:811",
+      "ov_cimguiname": "ImPlotAxis_UpdateTransformCache",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_WillRender": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotAxis_WillRender",
+      "defaults": {},
+      "funcname": "WillRender",
+      "location": "implot_internal:879",
+      "ov_cimguiname": "ImPlotAxis_WillRender",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotAxis_destroy": [
+    {
+      "args": "(ImPlotAxis* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotAxis*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotAxis_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotAxis_destroy",
+      "ret": "void",
+      "signature": "(ImPlotAxis*)",
+      "stname": "ImPlotAxis"
+    }
+  ],
+  "ImPlotColormapData_Append": [
+    {
+      "args": "(ImPlotColormapData* self,const char* name,const ImU32* keys,int count,bool qual)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "keys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "qual",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* name,const ImU32* keys,int count,bool qual)",
+      "call_args": "(name,keys,count,qual)",
+      "cimguiname": "ImPlotColormapData_Append",
+      "defaults": {},
+      "funcname": "Append",
+      "location": "implot_internal:338",
+      "ov_cimguiname": "ImPlotColormapData_Append",
+      "ret": "int",
+      "signature": "(const char*,const ImU32*,int,bool)",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetIndex": [
+    {
+      "args": "(ImPlotColormapData* self,const char* name)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "ImPlotColormapData_GetIndex",
+      "defaults": {},
+      "funcname": "GetIndex",
+      "location": "implot_internal:405",
+      "ov_cimguiname": "ImPlotColormapData_GetIndex",
+      "ret": "ImPlotColormap",
+      "signature": "(const char*)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetKeyColor": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap,int idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap,int idx)",
+      "call_args": "(cmap,idx)",
+      "cimguiname": "ImPlotColormapData_GetKeyColor",
+      "defaults": {},
+      "funcname": "GetKeyColor",
+      "location": "implot_internal:409",
+      "ov_cimguiname": "ImPlotColormapData_GetKeyColor",
+      "ret": "ImU32",
+      "signature": "(ImPlotColormap,int)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetKeyCount": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData_GetKeyCount",
+      "defaults": {},
+      "funcname": "GetKeyCount",
+      "location": "implot_internal:408",
+      "ov_cimguiname": "ImPlotColormapData_GetKeyCount",
+      "ret": "int",
+      "signature": "(ImPlotColormap)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetKeys": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData_GetKeys",
+      "defaults": {},
+      "funcname": "GetKeys",
+      "location": "implot_internal:407",
+      "ov_cimguiname": "ImPlotColormapData_GetKeys",
+      "ret": "const ImU32*",
+      "signature": "(ImPlotColormap)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetName": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData_GetName",
+      "defaults": {},
+      "funcname": "GetName",
+      "location": "implot_internal:404",
+      "ov_cimguiname": "ImPlotColormapData_GetName",
+      "ret": "const char*",
+      "signature": "(ImPlotColormap)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetTable": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData_GetTable",
+      "defaults": {},
+      "funcname": "GetTable",
+      "location": "implot_internal:412",
+      "ov_cimguiname": "ImPlotColormapData_GetTable",
+      "ret": "const ImU32*",
+      "signature": "(ImPlotColormap)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetTableColor": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap,int idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap,int idx)",
+      "call_args": "(cmap,idx)",
+      "cimguiname": "ImPlotColormapData_GetTableColor",
+      "defaults": {},
+      "funcname": "GetTableColor",
+      "location": "implot_internal:414",
+      "ov_cimguiname": "ImPlotColormapData_GetTableColor",
+      "ret": "ImU32",
+      "signature": "(ImPlotColormap,int)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_GetTableSize": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData_GetTableSize",
+      "defaults": {},
+      "funcname": "GetTableSize",
+      "location": "implot_internal:413",
+      "ov_cimguiname": "ImPlotColormapData_GetTableSize",
+      "ret": "int",
+      "signature": "(ImPlotColormap)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_ImPlotColormapData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotColormapData_ImPlotColormapData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotColormapData",
+      "location": "implot_internal:336",
+      "ov_cimguiname": "ImPlotColormapData_ImPlotColormapData",
+      "signature": "()",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_IsQual": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData_IsQual",
+      "defaults": {},
+      "funcname": "IsQual",
+      "location": "implot_internal:403",
+      "ov_cimguiname": "ImPlotColormapData_IsQual",
+      "ret": "bool",
+      "signature": "(ImPlotColormap)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_LerpTable": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap,float t)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap,float t)",
+      "call_args": "(cmap,t)",
+      "cimguiname": "ImPlotColormapData_LerpTable",
+      "defaults": {},
+      "funcname": "LerpTable",
+      "location": "implot_internal:416",
+      "ov_cimguiname": "ImPlotColormapData_LerpTable",
+      "ret": "ImU32",
+      "signature": "(ImPlotColormap,float)const",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_RebuildTables": [
+    {
+      "args": "(ImPlotColormapData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotColormapData_RebuildTables",
+      "defaults": {},
+      "funcname": "RebuildTables",
+      "location": "implot_internal:395",
+      "ov_cimguiname": "ImPlotColormapData_RebuildTables",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_SetKeyColor": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap,int idx,ImU32 value)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        },
+        {
+          "name": "value",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap,int idx,ImU32 value)",
+      "call_args": "(cmap,idx,value)",
+      "cimguiname": "ImPlotColormapData_SetKeyColor",
+      "defaults": {},
+      "funcname": "SetKeyColor",
+      "location": "implot_internal:410",
+      "ov_cimguiname": "ImPlotColormapData_SetKeyColor",
+      "ret": "void",
+      "signature": "(ImPlotColormap,int,ImU32)",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData__AppendTable": [
+    {
+      "args": "(ImPlotColormapData* self,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlotColormapData__AppendTable",
+      "defaults": {},
+      "funcname": "_AppendTable",
+      "location": "implot_internal:356",
+      "ov_cimguiname": "ImPlotColormapData__AppendTable",
+      "ret": "void",
+      "signature": "(ImPlotColormap)",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotColormapData_destroy": [
+    {
+      "args": "(ImPlotColormapData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotColormapData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotColormapData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotColormapData_destroy",
+      "ret": "void",
+      "signature": "(ImPlotColormapData*)",
+      "stname": "ImPlotColormapData"
+    }
+  ],
+  "ImPlotDateTimeSpec_ImPlotDateTimeSpec": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotDateTimeSpec_ImPlotDateTimeSpec",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotDateTimeSpec",
+      "location": "implot_internal:283",
+      "ov_cimguiname": "ImPlotDateTimeSpec_ImPlotDateTimeSpec_Nil",
+      "signature": "()",
+      "stname": "ImPlotDateTimeSpec"
+    },
+    {
+      "args": "(ImPlotDateFmt date_fmt,ImPlotTimeFmt time_fmt,bool use_24_hr_clk,bool use_iso_8601)",
+      "argsT": [
+        {
+          "name": "date_fmt",
+          "type": "ImPlotDateFmt"
+        },
+        {
+          "name": "time_fmt",
+          "type": "ImPlotTimeFmt"
+        },
+        {
+          "name": "use_24_hr_clk",
+          "type": "bool"
+        },
+        {
+          "name": "use_iso_8601",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImPlotDateFmt date_fmt,ImPlotTimeFmt time_fmt,bool use_24_hr_clk=false,bool use_iso_8601=false)",
+      "call_args": "(date_fmt,time_fmt,use_24_hr_clk,use_iso_8601)",
+      "cimguiname": "ImPlotDateTimeSpec_ImPlotDateTimeSpec",
+      "constructor": true,
+      "defaults": {
+        "use_24_hr_clk": "false",
+        "use_iso_8601": "false"
+      },
+      "funcname": "ImPlotDateTimeSpec",
+      "location": "implot_internal:284",
+      "ov_cimguiname": "ImPlotDateTimeSpec_ImPlotDateTimeSpec_PlotDateFmt",
+      "signature": "(ImPlotDateFmt,ImPlotTimeFmt,bool,bool)",
+      "stname": "ImPlotDateTimeSpec"
+    }
+  ],
+  "ImPlotDateTimeSpec_destroy": [
+    {
+      "args": "(ImPlotDateTimeSpec* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotDateTimeSpec*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotDateTimeSpec_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotDateTimeSpec_destroy",
+      "ret": "void",
+      "signature": "(ImPlotDateTimeSpec*)",
+      "stname": "ImPlotDateTimeSpec"
+    }
+  ],
+  "ImPlotInputMap_ImPlotInputMap": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotInputMap_ImPlotInputMap",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotInputMap",
+      "location": "implot:569",
+      "ov_cimguiname": "ImPlotInputMap_ImPlotInputMap",
+      "signature": "()",
+      "stname": "ImPlotInputMap"
+    }
+  ],
+  "ImPlotInputMap_destroy": [
+    {
+      "args": "(ImPlotInputMap* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotInputMap*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotInputMap_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotInputMap_destroy",
+      "ret": "void",
+      "signature": "(ImPlotInputMap*)",
+      "stname": "ImPlotInputMap"
+    }
+  ],
+  "ImPlotItemGroup_GetItem": [
+    {
+      "args": "(ImPlotItemGroup* self,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "ImPlotItemGroup_GetItem",
+      "defaults": {},
+      "funcname": "GetItem",
+      "location": "implot_internal:1001",
+      "ov_cimguiname": "ImPlotItemGroup_GetItem_ID",
+      "ret": "ImPlotItem*",
+      "signature": "(ImGuiID)",
+      "stname": "ImPlotItemGroup"
+    },
+    {
+      "args": "(ImPlotItemGroup* self,const char* label_id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "label_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label_id)",
+      "call_args": "(label_id)",
+      "cimguiname": "ImPlotItemGroup_GetItem",
+      "defaults": {},
+      "funcname": "GetItem",
+      "location": "implot_internal:1002",
+      "ov_cimguiname": "ImPlotItemGroup_GetItem_Str",
+      "ret": "ImPlotItem*",
+      "signature": "(const char*)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetItemByIndex": [
+    {
+      "args": "(ImPlotItemGroup* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotItemGroup_GetItemByIndex",
+      "defaults": {},
+      "funcname": "GetItemByIndex",
+      "location": "implot_internal:1004",
+      "ov_cimguiname": "ImPlotItemGroup_GetItemByIndex",
+      "ret": "ImPlotItem*",
+      "signature": "(int)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetItemCount": [
+    {
+      "args": "(ImPlotItemGroup* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotItemGroup_GetItemCount",
+      "defaults": {},
+      "funcname": "GetItemCount",
+      "location": "implot_internal:999",
+      "ov_cimguiname": "ImPlotItemGroup_GetItemCount",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetItemID": [
+    {
+      "args": "(ImPlotItemGroup* self,const char* label_id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "label_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label_id)",
+      "call_args": "(label_id)",
+      "cimguiname": "ImPlotItemGroup_GetItemID",
+      "defaults": {},
+      "funcname": "GetItemID",
+      "location": "implot_internal:1000",
+      "ov_cimguiname": "ImPlotItemGroup_GetItemID",
+      "ret": "ImGuiID",
+      "signature": "(const char*)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetItemIndex": [
+    {
+      "args": "(ImPlotItemGroup* self,ImPlotItem* item)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "item",
+          "type": "ImPlotItem*"
+        }
+      ],
+      "argsoriginal": "(ImPlotItem* item)",
+      "call_args": "(item)",
+      "cimguiname": "ImPlotItemGroup_GetItemIndex",
+      "defaults": {},
+      "funcname": "GetItemIndex",
+      "location": "implot_internal:1005",
+      "ov_cimguiname": "ImPlotItemGroup_GetItemIndex",
+      "ret": "int",
+      "signature": "(ImPlotItem*)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetLegendCount": [
+    {
+      "args": "(ImPlotItemGroup* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotItemGroup_GetLegendCount",
+      "defaults": {},
+      "funcname": "GetLegendCount",
+      "location": "implot_internal:1006",
+      "ov_cimguiname": "ImPlotItemGroup_GetLegendCount",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetLegendItem": [
+    {
+      "args": "(ImPlotItemGroup* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotItemGroup_GetLegendItem",
+      "defaults": {},
+      "funcname": "GetLegendItem",
+      "location": "implot_internal:1007",
+      "ov_cimguiname": "ImPlotItemGroup_GetLegendItem",
+      "ret": "ImPlotItem*",
+      "signature": "(int)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetLegendLabel": [
+    {
+      "args": "(ImPlotItemGroup* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotItemGroup_GetLegendLabel",
+      "defaults": {},
+      "funcname": "GetLegendLabel",
+      "location": "implot_internal:1008",
+      "ov_cimguiname": "ImPlotItemGroup_GetLegendLabel",
+      "ret": "const char*",
+      "signature": "(int)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_GetOrAddItem": [
+    {
+      "args": "(ImPlotItemGroup* self,ImGuiID id)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "id",
+          "type": "ImGuiID"
+        }
+      ],
+      "argsoriginal": "(ImGuiID id)",
+      "call_args": "(id)",
+      "cimguiname": "ImPlotItemGroup_GetOrAddItem",
+      "defaults": {},
+      "funcname": "GetOrAddItem",
+      "location": "implot_internal:1003",
+      "ov_cimguiname": "ImPlotItemGroup_GetOrAddItem",
+      "ret": "ImPlotItem*",
+      "signature": "(ImGuiID)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_ImPlotItemGroup": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotItemGroup_ImPlotItemGroup",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotItemGroup",
+      "location": "implot_internal:997",
+      "ov_cimguiname": "ImPlotItemGroup_ImPlotItemGroup",
+      "signature": "()",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_Reset": [
+    {
+      "args": "(ImPlotItemGroup* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotItemGroup_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:1009",
+      "ov_cimguiname": "ImPlotItemGroup_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItemGroup_destroy": [
+    {
+      "args": "(ImPlotItemGroup* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItemGroup*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotItemGroup_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotItemGroup_destroy",
+      "ret": "void",
+      "signature": "(ImPlotItemGroup*)",
+      "stname": "ImPlotItemGroup"
+    }
+  ],
+  "ImPlotItem_ImPlotItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotItem_ImPlotItem",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotItem",
+      "location": "implot_internal:953",
+      "ov_cimguiname": "ImPlotItem_ImPlotItem",
+      "signature": "()",
+      "stname": "ImPlotItem"
+    }
+  ],
+  "ImPlotItem_destroy": [
+    {
+      "args": "(ImPlotItem* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotItem*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotItem_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "implot_internal:962",
+      "ov_cimguiname": "ImPlotItem_destroy",
+      "realdestructor": true,
+      "ret": "void",
+      "signature": "(ImPlotItem*)",
+      "stname": "ImPlotItem"
+    }
+  ],
+  "ImPlotLegend_ImPlotLegend": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotLegend_ImPlotLegend",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotLegend",
+      "location": "implot_internal:979",
+      "ov_cimguiname": "ImPlotLegend_ImPlotLegend",
+      "signature": "()",
+      "stname": "ImPlotLegend"
+    }
+  ],
+  "ImPlotLegend_Reset": [
+    {
+      "args": "(ImPlotLegend* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotLegend*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotLegend_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:986",
+      "ov_cimguiname": "ImPlotLegend_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotLegend"
+    }
+  ],
+  "ImPlotLegend_destroy": [
+    {
+      "args": "(ImPlotLegend* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotLegend*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotLegend_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotLegend_destroy",
+      "ret": "void",
+      "signature": "(ImPlotLegend*)",
+      "stname": "ImPlotLegend"
+    }
+  ],
+  "ImPlotNextItemData_ImPlotNextItemData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotNextItemData_ImPlotNextItemData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotNextItemData",
+      "location": "implot_internal:1194",
+      "ov_cimguiname": "ImPlotNextItemData_ImPlotNextItemData",
+      "signature": "()",
+      "stname": "ImPlotNextItemData"
+    }
+  ],
+  "ImPlotNextItemData_Reset": [
+    {
+      "args": "(ImPlotNextItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotNextItemData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotNextItemData_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:1195",
+      "ov_cimguiname": "ImPlotNextItemData_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotNextItemData"
+    }
+  ],
+  "ImPlotNextItemData_destroy": [
+    {
+      "args": "(ImPlotNextItemData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotNextItemData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotNextItemData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotNextItemData_destroy",
+      "ret": "void",
+      "signature": "(ImPlotNextItemData*)",
+      "stname": "ImPlotNextItemData"
+    }
+  ],
+  "ImPlotNextPlotData_ImPlotNextPlotData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotNextPlotData_ImPlotNextPlotData",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotNextPlotData",
+      "location": "implot_internal:1163",
+      "ov_cimguiname": "ImPlotNextPlotData_ImPlotNextPlotData",
+      "signature": "()",
+      "stname": "ImPlotNextPlotData"
+    }
+  ],
+  "ImPlotNextPlotData_Reset": [
+    {
+      "args": "(ImPlotNextPlotData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotNextPlotData*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotNextPlotData_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:1165",
+      "ov_cimguiname": "ImPlotNextPlotData_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotNextPlotData"
+    }
+  ],
+  "ImPlotNextPlotData_destroy": [
+    {
+      "args": "(ImPlotNextPlotData* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotNextPlotData*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotNextPlotData_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotNextPlotData_destroy",
+      "ret": "void",
+      "signature": "(ImPlotNextPlotData*)",
+      "stname": "ImPlotNextPlotData"
+    }
+  ],
+  "ImPlotPlot_ClearTextBuffer": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_ClearTextBuffer",
+      "defaults": {},
+      "funcname": "ClearTextBuffer",
+      "location": "implot_internal:1071",
+      "ov_cimguiname": "ImPlotPlot_ClearTextBuffer",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_EnabledAxesX": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_EnabledAxesX",
+      "defaults": {},
+      "funcname": "EnabledAxesX",
+      "location": "implot_internal:1090",
+      "ov_cimguiname": "ImPlotPlot_EnabledAxesX",
+      "ret": "int",
+      "signature": "()",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_EnabledAxesY": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_EnabledAxesY",
+      "defaults": {},
+      "funcname": "EnabledAxesY",
+      "location": "implot_internal:1097",
+      "ov_cimguiname": "ImPlotPlot_EnabledAxesY",
+      "ret": "int",
+      "signature": "()",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_GetAxisLabel": [
+    {
+      "args": "(ImPlotPlot* self,const ImPlotAxis axis)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "axis",
+          "type": "const ImPlotAxis"
+        }
+      ],
+      "argsoriginal": "(const ImPlotAxis& axis)",
+      "call_args": "(axis)",
+      "cimguiname": "ImPlotPlot_GetAxisLabel",
+      "defaults": {},
+      "funcname": "GetAxisLabel",
+      "location": "implot_internal:1114",
+      "ov_cimguiname": "ImPlotPlot_GetAxisLabel",
+      "ret": "const char*",
+      "signature": "(const ImPlotAxis)const",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_GetTitle": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_GetTitle",
+      "defaults": {},
+      "funcname": "GetTitle",
+      "location": "implot_internal:1083",
+      "ov_cimguiname": "ImPlotPlot_GetTitle",
+      "ret": "const char*",
+      "signature": "()const",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_HasTitle": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_HasTitle",
+      "defaults": {},
+      "funcname": "HasTitle",
+      "location": "implot_internal:1082",
+      "ov_cimguiname": "ImPlotPlot_HasTitle",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_ImPlotPlot": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_ImPlotPlot",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotPlot",
+      "location": "implot_internal:1042",
+      "ov_cimguiname": "ImPlotPlot_ImPlotPlot",
+      "signature": "()",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_IsInputLocked": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPlot_IsInputLocked",
+      "defaults": {},
+      "funcname": "IsInputLocked",
+      "location": "implot_internal:1059",
+      "ov_cimguiname": "ImPlotPlot_IsInputLocked",
+      "ret": "bool",
+      "signature": "()const",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_SetAxisLabel": [
+    {
+      "args": "(ImPlotPlot* self,ImPlotAxis* axis,const char* label)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "axis",
+          "reftoptr": true,
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis& axis,const char* label)",
+      "call_args": "(*axis,label)",
+      "cimguiname": "ImPlotPlot_SetAxisLabel",
+      "defaults": {},
+      "funcname": "SetAxisLabel",
+      "location": "implot_internal:1104",
+      "ov_cimguiname": "ImPlotPlot_SetAxisLabel",
+      "ret": "void",
+      "signature": "(ImPlotAxis*,const char*)",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_SetTitle": [
+    {
+      "args": "(ImPlotPlot* self,const char* title)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "title",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* title)",
+      "call_args": "(title)",
+      "cimguiname": "ImPlotPlot_SetTitle",
+      "defaults": {},
+      "funcname": "SetTitle",
+      "location": "implot_internal:1073",
+      "ov_cimguiname": "ImPlotPlot_SetTitle",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_XAxis": [
+    {
+      "args": "(ImPlotPlot* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotPlot_XAxis",
+      "defaults": {},
+      "funcname": "XAxis",
+      "location": "implot_internal:1085",
+      "ov_cimguiname": "ImPlotPlot_XAxis_Nil",
+      "ret": "ImPlotAxis*",
+      "retref": "&",
+      "signature": "(int)",
+      "stname": "ImPlotPlot"
+    },
+    {
+      "args": "(ImPlotPlot* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotPlot_XAxis",
+      "defaults": {},
+      "funcname": "XAxis",
+      "location": "implot_internal:1086",
+      "ov_cimguiname": "ImPlotPlot_XAxis__const",
+      "ret": "const ImPlotAxis*",
+      "retref": "&",
+      "signature": "(int)const",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_YAxis": [
+    {
+      "args": "(ImPlotPlot* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotPlot_YAxis",
+      "defaults": {},
+      "funcname": "YAxis",
+      "location": "implot_internal:1087",
+      "ov_cimguiname": "ImPlotPlot_YAxis_Nil",
+      "ret": "ImPlotAxis*",
+      "retref": "&",
+      "signature": "(int)",
+      "stname": "ImPlotPlot"
+    },
+    {
+      "args": "(ImPlotPlot* self,int i)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        },
+        {
+          "name": "i",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int i)",
+      "call_args": "(i)",
+      "cimguiname": "ImPlotPlot_YAxis",
+      "defaults": {},
+      "funcname": "YAxis",
+      "location": "implot_internal:1088",
+      "ov_cimguiname": "ImPlotPlot_YAxis__const",
+      "ret": "const ImPlotAxis*",
+      "retref": "&",
+      "signature": "(int)const",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPlot_destroy": [
+    {
+      "args": "(ImPlotPlot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotPlot_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotPlot_destroy",
+      "ret": "void",
+      "signature": "(ImPlotPlot*)",
+      "stname": "ImPlotPlot"
+    }
+  ],
+  "ImPlotPointError_ImPlotPointError": [
+    {
+      "args": "(double x,double y,double neg,double pos)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "neg",
+          "type": "double"
+        },
+        {
+          "name": "pos",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x,double y,double neg,double pos)",
+      "call_args": "(x,y,neg,pos)",
+      "cimguiname": "ImPlotPointError_ImPlotPointError",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotPointError",
+      "location": "implot_internal:427",
+      "ov_cimguiname": "ImPlotPointError_ImPlotPointError",
+      "signature": "(double,double,double,double)",
+      "stname": "ImPlotPointError"
+    }
+  ],
+  "ImPlotPointError_destroy": [
+    {
+      "args": "(ImPlotPointError* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPointError*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotPointError_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotPointError_destroy",
+      "ret": "void",
+      "signature": "(ImPlotPointError*)",
+      "stname": "ImPlotPointError"
+    }
+  ],
+  "ImPlotPoint_ImPlotPoint": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotPoint_ImPlotPoint",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotPoint",
+      "location": "implot:469",
+      "ov_cimguiname": "ImPlotPoint_ImPlotPoint_Nil",
+      "signature": "()",
+      "stname": "ImPlotPoint"
+    },
+    {
+      "args": "(double _x,double _y)",
+      "argsT": [
+        {
+          "name": "_x",
+          "type": "double"
+        },
+        {
+          "name": "_y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double _x,double _y)",
+      "call_args": "(_x,_y)",
+      "cimguiname": "ImPlotPoint_ImPlotPoint",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotPoint",
+      "location": "implot:470",
+      "ov_cimguiname": "ImPlotPoint_ImPlotPoint_double",
+      "signature": "(double,double)",
+      "stname": "ImPlotPoint"
+    },
+    {
+      "args": "(const ImVec2 p)",
+      "argsT": [
+        {
+          "name": "p",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& p)",
+      "call_args": "(p)",
+      "cimguiname": "ImPlotPoint_ImPlotPoint",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotPoint",
+      "location": "implot:471",
+      "ov_cimguiname": "ImPlotPoint_ImPlotPoint_Vec2",
+      "signature": "(const ImVec2)",
+      "stname": "ImPlotPoint"
+    }
+  ],
+  "ImPlotPoint_destroy": [
+    {
+      "args": "(ImPlotPoint* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotPoint*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotPoint_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotPoint_destroy",
+      "ret": "void",
+      "signature": "(ImPlotPoint*)",
+      "stname": "ImPlotPoint"
+    }
+  ],
+  "ImPlotRange_Clamp": [
+    {
+      "args": "(ImPlotRange* self,double value)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRange*"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double value)",
+      "call_args": "(value)",
+      "cimguiname": "ImPlotRange_Clamp",
+      "defaults": {},
+      "funcname": "Clamp",
+      "location": "implot:487",
+      "ov_cimguiname": "ImPlotRange_Clamp",
+      "ret": "double",
+      "signature": "(double)const",
+      "stname": "ImPlotRange"
+    }
+  ],
+  "ImPlotRange_Contains": [
+    {
+      "args": "(ImPlotRange* self,double value)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRange*"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double value)",
+      "call_args": "(value)",
+      "cimguiname": "ImPlotRange_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "implot:485",
+      "ov_cimguiname": "ImPlotRange_Contains",
+      "ret": "bool",
+      "signature": "(double)const",
+      "stname": "ImPlotRange"
+    }
+  ],
+  "ImPlotRange_ImPlotRange": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotRange_ImPlotRange",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotRange",
+      "location": "implot:483",
+      "ov_cimguiname": "ImPlotRange_ImPlotRange_Nil",
+      "signature": "()",
+      "stname": "ImPlotRange"
+    },
+    {
+      "args": "(double _min,double _max)",
+      "argsT": [
+        {
+          "name": "_min",
+          "type": "double"
+        },
+        {
+          "name": "_max",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double _min,double _max)",
+      "call_args": "(_min,_max)",
+      "cimguiname": "ImPlotRange_ImPlotRange",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotRange",
+      "location": "implot:484",
+      "ov_cimguiname": "ImPlotRange_ImPlotRange_double",
+      "signature": "(double,double)",
+      "stname": "ImPlotRange"
+    }
+  ],
+  "ImPlotRange_Size": [
+    {
+      "args": "(ImPlotRange* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRange*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotRange_Size",
+      "defaults": {},
+      "funcname": "Size",
+      "location": "implot:486",
+      "ov_cimguiname": "ImPlotRange_Size",
+      "ret": "double",
+      "signature": "()const",
+      "stname": "ImPlotRange"
+    }
+  ],
+  "ImPlotRange_destroy": [
+    {
+      "args": "(ImPlotRange* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRange*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotRange_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotRange_destroy",
+      "ret": "void",
+      "signature": "(ImPlotRange*)",
+      "stname": "ImPlotRange"
+    }
+  ],
+  "ImPlotRect_Clamp": [
+    {
+      "args": "(ImPlotPoint *pOut,ImPlotRect* self,const ImPlotPoint p)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        },
+        {
+          "name": "p",
+          "type": "const ImPlotPoint"
+        }
+      ],
+      "argsoriginal": "(const ImPlotPoint& p)",
+      "call_args": "(p)",
+      "cimguiname": "ImPlotRect_Clamp",
+      "defaults": {},
+      "funcname": "Clamp",
+      "location": "implot:498",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlotRect_Clamp_PlotPoInt",
+      "ret": "void",
+      "signature": "(const ImPlotPoint)",
+      "stname": "ImPlotRect"
+    },
+    {
+      "args": "(ImPlotPoint *pOut,ImPlotRect* self,double x,double y)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x,double y)",
+      "call_args": "(x,y)",
+      "cimguiname": "ImPlotRect_Clamp",
+      "defaults": {},
+      "funcname": "Clamp",
+      "location": "implot:499",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlotRect_Clamp_double",
+      "ret": "void",
+      "signature": "(double,double)",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotRect_Contains": [
+    {
+      "args": "(ImPlotRect* self,const ImPlotPoint p)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        },
+        {
+          "name": "p",
+          "type": "const ImPlotPoint"
+        }
+      ],
+      "argsoriginal": "(const ImPlotPoint& p)",
+      "call_args": "(p)",
+      "cimguiname": "ImPlotRect_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "implot:495",
+      "ov_cimguiname": "ImPlotRect_Contains_PlotPoInt",
+      "ret": "bool",
+      "signature": "(const ImPlotPoint)const",
+      "stname": "ImPlotRect"
+    },
+    {
+      "args": "(ImPlotRect* self,double x,double y)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x,double y)",
+      "call_args": "(x,y)",
+      "cimguiname": "ImPlotRect_Contains",
+      "defaults": {},
+      "funcname": "Contains",
+      "location": "implot:496",
+      "ov_cimguiname": "ImPlotRect_Contains_double",
+      "ret": "bool",
+      "signature": "(double,double)const",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotRect_ImPlotRect": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotRect_ImPlotRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotRect",
+      "location": "implot:493",
+      "ov_cimguiname": "ImPlotRect_ImPlotRect_Nil",
+      "signature": "()",
+      "stname": "ImPlotRect"
+    },
+    {
+      "args": "(double x_min,double x_max,double y_min,double y_max)",
+      "argsT": [
+        {
+          "name": "x_min",
+          "type": "double"
+        },
+        {
+          "name": "x_max",
+          "type": "double"
+        },
+        {
+          "name": "y_min",
+          "type": "double"
+        },
+        {
+          "name": "y_max",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x_min,double x_max,double y_min,double y_max)",
+      "call_args": "(x_min,x_max,y_min,y_max)",
+      "cimguiname": "ImPlotRect_ImPlotRect",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotRect",
+      "location": "implot:494",
+      "ov_cimguiname": "ImPlotRect_ImPlotRect_double",
+      "signature": "(double,double,double,double)",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotRect_Max": [
+    {
+      "args": "(ImPlotPoint *pOut,ImPlotRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotRect_Max",
+      "defaults": {},
+      "funcname": "Max",
+      "location": "implot:501",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlotRect_Max",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotRect_Min": [
+    {
+      "args": "(ImPlotPoint *pOut,ImPlotRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotRect_Min",
+      "defaults": {},
+      "funcname": "Min",
+      "location": "implot:500",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlotRect_Min",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotRect_Size": [
+    {
+      "args": "(ImPlotPoint *pOut,ImPlotRect* self)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotRect_Size",
+      "defaults": {},
+      "funcname": "Size",
+      "location": "implot:497",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlotRect_Size",
+      "ret": "void",
+      "signature": "()const",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotRect_destroy": [
+    {
+      "args": "(ImPlotRect* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotRect*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotRect_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotRect_destroy",
+      "ret": "void",
+      "signature": "(ImPlotRect*)",
+      "stname": "ImPlotRect"
+    }
+  ],
+  "ImPlotStyle_ImPlotStyle": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotStyle_ImPlotStyle",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotStyle",
+      "location": "implot:543",
+      "ov_cimguiname": "ImPlotStyle_ImPlotStyle",
+      "signature": "()",
+      "stname": "ImPlotStyle"
+    }
+  ],
+  "ImPlotStyle_destroy": [
+    {
+      "args": "(ImPlotStyle* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotStyle*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotStyle_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotStyle_destroy",
+      "ret": "void",
+      "signature": "(ImPlotStyle*)",
+      "stname": "ImPlotStyle"
+    }
+  ],
+  "ImPlotSubplot_ImPlotSubplot": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotSubplot_ImPlotSubplot",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotSubplot",
+      "location": "implot_internal:1139",
+      "ov_cimguiname": "ImPlotSubplot_ImPlotSubplot",
+      "signature": "()",
+      "stname": "ImPlotSubplot"
+    }
+  ],
+  "ImPlotSubplot_destroy": [
+    {
+      "args": "(ImPlotSubplot* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotSubplot*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotSubplot_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotSubplot_destroy",
+      "ret": "void",
+      "signature": "(ImPlotSubplot*)",
+      "stname": "ImPlotSubplot"
+    }
+  ],
+  "ImPlotTagCollection_Append": [
+    {
+      "args": "(ImPlotTagCollection* self,ImAxis axis,double value,ImU32 bg,ImU32 fg,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTagCollection*"
+        },
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "bg",
+          "type": "ImU32"
+        },
+        {
+          "name": "fg",
+          "type": "ImU32"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double value,ImU32 bg,ImU32 fg,const char* fmt,...)",
+      "call_args": "(axis,value,bg,fg,fmt,...)",
+      "cimguiname": "ImPlotTagCollection_Append",
+      "defaults": {},
+      "funcname": "Append",
+      "isvararg": "...)",
+      "location": "implot_internal:517",
+      "ov_cimguiname": "ImPlotTagCollection_Append",
+      "ret": "void",
+      "signature": "(ImAxis,double,ImU32,ImU32,const char*,...)",
+      "stname": "ImPlotTagCollection"
+    }
+  ],
+  "ImPlotTagCollection_AppendV": [
+    {
+      "args": "(ImPlotTagCollection* self,ImAxis axis,double value,ImU32 bg,ImU32 fg,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTagCollection*"
+        },
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "bg",
+          "type": "ImU32"
+        },
+        {
+          "name": "fg",
+          "type": "ImU32"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double value,ImU32 bg,ImU32 fg,const char* fmt,va_list args)",
+      "call_args": "(axis,value,bg,fg,fmt,args)",
+      "cimguiname": "ImPlotTagCollection_AppendV",
+      "defaults": {},
+      "funcname": "AppendV",
+      "location": "implot_internal:503",
+      "ov_cimguiname": "ImPlotTagCollection_AppendV",
+      "ret": "void",
+      "signature": "(ImAxis,double,ImU32,ImU32,const char*,va_list)",
+      "stname": "ImPlotTagCollection"
+    }
+  ],
+  "ImPlotTagCollection_GetText": [
+    {
+      "args": "(ImPlotTagCollection* self,int idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTagCollection*"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlotTagCollection_GetText",
+      "defaults": {},
+      "funcname": "GetText",
+      "location": "implot_internal:524",
+      "ov_cimguiname": "ImPlotTagCollection_GetText",
+      "ret": "const char*",
+      "signature": "(int)",
+      "stname": "ImPlotTagCollection"
+    }
+  ],
+  "ImPlotTagCollection_ImPlotTagCollection": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTagCollection_ImPlotTagCollection",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotTagCollection",
+      "location": "implot_internal:501",
+      "ov_cimguiname": "ImPlotTagCollection_ImPlotTagCollection",
+      "signature": "()",
+      "stname": "ImPlotTagCollection"
+    }
+  ],
+  "ImPlotTagCollection_Reset": [
+    {
+      "args": "(ImPlotTagCollection* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTagCollection*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTagCollection_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:528",
+      "ov_cimguiname": "ImPlotTagCollection_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotTagCollection"
+    }
+  ],
+  "ImPlotTagCollection_destroy": [
+    {
+      "args": "(ImPlotTagCollection* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTagCollection*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotTagCollection_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotTagCollection_destroy",
+      "ret": "void",
+      "signature": "(ImPlotTagCollection*)",
+      "stname": "ImPlotTagCollection"
+    }
+  ],
+  "ImPlotTick_ImPlotTick": [
+    {
+      "args": "(double value,bool major,int level,bool show_label)",
+      "argsT": [
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "major",
+          "type": "bool"
+        },
+        {
+          "name": "level",
+          "type": "int"
+        },
+        {
+          "name": "show_label",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double value,bool major,int level,bool show_label)",
+      "call_args": "(value,major,level,show_label)",
+      "cimguiname": "ImPlotTick_ImPlotTick",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotTick",
+      "location": "implot_internal:547",
+      "ov_cimguiname": "ImPlotTick_ImPlotTick",
+      "signature": "(double,bool,int,bool)",
+      "stname": "ImPlotTick"
+    }
+  ],
+  "ImPlotTick_destroy": [
+    {
+      "args": "(ImPlotTick* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTick*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotTick_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotTick_destroy",
+      "ret": "void",
+      "signature": "(ImPlotTick*)",
+      "stname": "ImPlotTick"
+    }
+  ],
+  "ImPlotTicker_AddTick": [
+    {
+      "args": "(ImPlotTicker* self,double value,bool major,int level,bool show_label,const char* label)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "major",
+          "type": "bool"
+        },
+        {
+          "name": "level",
+          "type": "int"
+        },
+        {
+          "name": "show_label",
+          "type": "bool"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(double value,bool major,int level,bool show_label,const char* label)",
+      "call_args": "(value,major,level,show_label,label)",
+      "cimguiname": "ImPlotTicker_AddTick",
+      "defaults": {},
+      "funcname": "AddTick",
+      "location": "implot_internal:569",
+      "ov_cimguiname": "ImPlotTicker_AddTick_doubleStr",
+      "ret": "ImPlotTick*",
+      "retref": "&",
+      "signature": "(double,bool,int,bool,const char*)",
+      "stname": "ImPlotTicker"
+    },
+    {
+      "args": "(ImPlotTicker* self,double value,bool major,int level,bool show_label,ImPlotFormatter formatter,void* data)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "major",
+          "type": "bool"
+        },
+        {
+          "name": "level",
+          "type": "int"
+        },
+        {
+          "name": "show_label",
+          "type": "bool"
+        },
+        {
+          "name": "formatter",
+          "type": "ImPlotFormatter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double value,bool major,int level,bool show_label,ImPlotFormatter formatter,void* data)",
+      "call_args": "(value,major,level,show_label,formatter,data)",
+      "cimguiname": "ImPlotTicker_AddTick",
+      "defaults": {},
+      "funcname": "AddTick",
+      "location": "implot_internal:579",
+      "ov_cimguiname": "ImPlotTicker_AddTick_doublePlotFormatter",
+      "ret": "ImPlotTick*",
+      "retref": "&",
+      "signature": "(double,bool,int,bool,ImPlotFormatter,void*)",
+      "stname": "ImPlotTicker"
+    },
+    {
+      "args": "(ImPlotTicker* self,ImPlotTick tick)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "tick",
+          "type": "ImPlotTick"
+        }
+      ],
+      "argsoriginal": "(ImPlotTick tick)",
+      "call_args": "(tick)",
+      "cimguiname": "ImPlotTicker_AddTick",
+      "defaults": {},
+      "funcname": "AddTick",
+      "location": "implot_internal:591",
+      "ov_cimguiname": "ImPlotTicker_AddTick_PlotTick",
+      "ret": "ImPlotTick*",
+      "retref": "&",
+      "signature": "(ImPlotTick)",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTicker_GetText": [
+    {
+      "args": "(ImPlotTicker* self,int idx)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlotTicker_GetText",
+      "defaults": {},
+      "funcname": "GetText",
+      "location": "implot_internal:601",
+      "ov_cimguiname": "ImPlotTicker_GetText_Int",
+      "ret": "const char*",
+      "signature": "(int)const",
+      "stname": "ImPlotTicker"
+    },
+    {
+      "args": "(ImPlotTicker* self,const ImPlotTick tick)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "tick",
+          "type": "const ImPlotTick"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTick& tick)",
+      "call_args": "(tick)",
+      "cimguiname": "ImPlotTicker_GetText",
+      "defaults": {},
+      "funcname": "GetText",
+      "location": "implot_internal:605",
+      "ov_cimguiname": "ImPlotTicker_GetText_PlotTick",
+      "ret": "const char*",
+      "signature": "(const ImPlotTick)",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTicker_ImPlotTicker": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTicker_ImPlotTicker",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotTicker",
+      "location": "implot_internal:565",
+      "ov_cimguiname": "ImPlotTicker_ImPlotTicker",
+      "signature": "()",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTicker_OverrideSizeLate": [
+    {
+      "args": "(ImPlotTicker* self,const ImVec2 size)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& size)",
+      "call_args": "(size)",
+      "cimguiname": "ImPlotTicker_OverrideSizeLate",
+      "defaults": {},
+      "funcname": "OverrideSizeLate",
+      "location": "implot_internal:609",
+      "ov_cimguiname": "ImPlotTicker_OverrideSizeLate",
+      "ret": "void",
+      "signature": "(const ImVec2)",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTicker_Reset": [
+    {
+      "args": "(ImPlotTicker* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTicker_Reset",
+      "defaults": {},
+      "funcname": "Reset",
+      "location": "implot_internal:614",
+      "ov_cimguiname": "ImPlotTicker_Reset",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTicker_TickCount": [
+    {
+      "args": "(ImPlotTicker* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTicker_TickCount",
+      "defaults": {},
+      "funcname": "TickCount",
+      "location": "implot_internal:622",
+      "ov_cimguiname": "ImPlotTicker_TickCount",
+      "ret": "int",
+      "signature": "()const",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTicker_destroy": [
+    {
+      "args": "(ImPlotTicker* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTicker*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotTicker_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotTicker_destroy",
+      "ret": "void",
+      "signature": "(ImPlotTicker*)",
+      "stname": "ImPlotTicker"
+    }
+  ],
+  "ImPlotTime_FromDouble": [
+    {
+      "args": "(ImPlotTime *pOut,double t)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "t",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double t)",
+      "call_args": "(t)",
+      "cimguiname": "ImPlotTime_FromDouble",
+      "defaults": {},
+      "funcname": "FromDouble",
+      "is_static_function": true,
+      "location": "implot_internal:304",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlotTime_FromDouble",
+      "ret": "void",
+      "signature": "(double)",
+      "stname": "ImPlotTime"
+    }
+  ],
+  "ImPlotTime_ImPlotTime": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTime_ImPlotTime",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImPlotTime",
+      "location": "implot_internal:300",
+      "ov_cimguiname": "ImPlotTime_ImPlotTime_Nil",
+      "signature": "()",
+      "stname": "ImPlotTime"
+    },
+    {
+      "args": "(time_t s,int us)",
+      "argsT": [
+        {
+          "name": "s",
+          "type": "time_t"
+        },
+        {
+          "name": "us",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(time_t s,int us=0)",
+      "call_args": "(s,us)",
+      "cimguiname": "ImPlotTime_ImPlotTime",
+      "constructor": true,
+      "defaults": {
+        "us": "0"
+      },
+      "funcname": "ImPlotTime",
+      "location": "implot_internal:301",
+      "ov_cimguiname": "ImPlotTime_ImPlotTime_time_t",
+      "signature": "(time_t,int)",
+      "stname": "ImPlotTime"
+    }
+  ],
+  "ImPlotTime_RollOver": [
+    {
+      "args": "(ImPlotTime* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTime*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTime_RollOver",
+      "defaults": {},
+      "funcname": "RollOver",
+      "location": "implot_internal:302",
+      "ov_cimguiname": "ImPlotTime_RollOver",
+      "ret": "void",
+      "signature": "()",
+      "stname": "ImPlotTime"
+    }
+  ],
+  "ImPlotTime_ToDouble": [
+    {
+      "args": "(ImPlotTime* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTime*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlotTime_ToDouble",
+      "defaults": {},
+      "funcname": "ToDouble",
+      "location": "implot_internal:303",
+      "ov_cimguiname": "ImPlotTime_ToDouble",
+      "ret": "double",
+      "signature": "()const",
+      "stname": "ImPlotTime"
+    }
+  ],
+  "ImPlotTime_destroy": [
+    {
+      "args": "(ImPlotTime* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImPlotTime*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImPlotTime_destroy",
+      "defaults": {},
+      "destructor": true,
+      "ov_cimguiname": "ImPlotTime_destroy",
+      "ret": "void",
+      "signature": "(ImPlotTime*)",
+      "stname": "ImPlotTime"
+    }
+  ],
+  "ImPlot_AddColormap": [
+    {
+      "args": "(const char* name,const ImVec4* cols,int size,bool qual)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "cols",
+          "type": "const ImVec4*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "qual",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* name,const ImVec4* cols,int size,bool qual=true)",
+      "call_args": "(name,cols,size,qual)",
+      "cimguiname": "ImPlot_AddColormap",
+      "defaults": {
+        "qual": "true"
+      },
+      "funcname": "AddColormap",
+      "location": "implot:1142",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AddColormap_Vec4Ptr",
+      "ret": "ImPlotColormap",
+      "signature": "(const char*,const ImVec4*,int,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* name,const ImU32* cols,int size,bool qual)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        },
+        {
+          "name": "cols",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "qual",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* name,const ImU32* cols,int size,bool qual=true)",
+      "call_args": "(name,cols,size,qual)",
+      "cimguiname": "ImPlot_AddColormap",
+      "defaults": {
+        "qual": "true"
+      },
+      "funcname": "AddColormap",
+      "location": "implot:1143",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AddColormap_U32Ptr",
+      "ret": "ImPlotColormap",
+      "signature": "(const char*,const ImU32*,int,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AddTextCentered": [
+    {
+      "args": "(ImDrawList* DrawList,ImVec2 top_center,ImU32 col,const char* text_begin,const char* text_end)",
+      "argsT": [
+        {
+          "name": "DrawList",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "top_center",
+          "type": "ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "text_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* DrawList,ImVec2 top_center,ImU32 col,const char* text_begin,const char* text_end=((void*)0))",
+      "call_args": "(DrawList,top_center,col,text_begin,text_end)",
+      "cimguiname": "ImPlot_AddTextCentered",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "AddTextCentered",
+      "location": "implot_internal:1457",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AddTextCentered",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImU32,const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AddTextVertical": [
+    {
+      "args": "(ImDrawList* DrawList,ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end)",
+      "argsT": [
+        {
+          "name": "DrawList",
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "text_begin",
+          "type": "const char*"
+        },
+        {
+          "name": "text_end",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImDrawList* DrawList,ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end=((void*)0))",
+      "call_args": "(DrawList,pos,col,text_begin,text_end)",
+      "cimguiname": "ImPlot_AddTextVertical",
+      "defaults": {
+        "text_end": "NULL"
+      },
+      "funcname": "AddTextVertical",
+      "location": "implot_internal:1455",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AddTextVertical",
+      "ret": "void",
+      "signature": "(ImDrawList*,ImVec2,ImU32,const char*,const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AddTime": [
+    {
+      "args": "(ImPlotTime *pOut,const ImPlotTime t,ImPlotTimeUnit unit,int count)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "unit",
+          "type": "ImPlotTimeUnit"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,ImPlotTimeUnit unit,int count)",
+      "call_args": "(t,unit,count)",
+      "cimguiname": "ImPlot_AddTime",
+      "defaults": {},
+      "funcname": "AddTime",
+      "location": "implot_internal:1575",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_AddTime",
+      "ret": "void",
+      "signature": "(const ImPlotTime,ImPlotTimeUnit,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AllAxesInputLocked": [
+    {
+      "args": "(ImPlotAxis* axes,int count)",
+      "argsT": [
+        {
+          "name": "axes",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis* axes,int count)",
+      "call_args": "(axes,count)",
+      "cimguiname": "ImPlot_AllAxesInputLocked",
+      "defaults": {},
+      "funcname": "AllAxesInputLocked",
+      "location": "implot_internal:1355",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AllAxesInputLocked",
+      "ret": "bool",
+      "signature": "(ImPlotAxis*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Annotation": [
+    {
+      "args": "(double x,double y,const ImVec4 col,const ImVec2 pix_offset,bool clamp,bool round)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "pix_offset",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clamp",
+          "type": "bool"
+        },
+        {
+          "name": "round",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double x,double y,const ImVec4& col,const ImVec2& pix_offset,bool clamp,bool round=false)",
+      "call_args": "(x,y,col,pix_offset,clamp,round)",
+      "cimguiname": "ImPlot_Annotation",
+      "defaults": {
+        "round": "false"
+      },
+      "funcname": "Annotation",
+      "location": "implot:932",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Annotation_Bool",
+      "ret": "void",
+      "signature": "(double,double,const ImVec4,const ImVec2,bool,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(double x,double y,const ImVec4 col,const ImVec2 pix_offset,bool clamp,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "pix_offset",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clamp",
+          "type": "bool"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(double x,double y,const ImVec4& col,const ImVec2& pix_offset,bool clamp,const char* fmt,...)",
+      "call_args": "(x,y,col,pix_offset,clamp,fmt,...)",
+      "cimguiname": "ImPlot_Annotation",
+      "defaults": {},
+      "funcname": "Annotation",
+      "isvararg": "...)",
+      "location": "implot:933",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Annotation_Str",
+      "ret": "void",
+      "signature": "(double,double,const ImVec4,const ImVec2,bool,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AnnotationV": [
+    {
+      "args": "(double x,double y,const ImVec4 col,const ImVec2 pix_offset,bool clamp,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "pix_offset",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "clamp",
+          "type": "bool"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(double x,double y,const ImVec4& col,const ImVec2& pix_offset,bool clamp,const char* fmt,va_list args)",
+      "call_args": "(x,y,col,pix_offset,clamp,fmt,args)",
+      "cimguiname": "ImPlot_AnnotationV",
+      "defaults": {},
+      "funcname": "AnnotationV",
+      "location": "implot:934",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AnnotationV",
+      "ret": "void",
+      "signature": "(double,double,const ImVec4,const ImVec2,bool,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AnyAxesHeld": [
+    {
+      "args": "(ImPlotAxis* axes,int count)",
+      "argsT": [
+        {
+          "name": "axes",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis* axes,int count)",
+      "call_args": "(axes,count)",
+      "cimguiname": "ImPlot_AnyAxesHeld",
+      "defaults": {},
+      "funcname": "AnyAxesHeld",
+      "location": "implot_internal:1363",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AnyAxesHeld",
+      "ret": "bool",
+      "signature": "(ImPlotAxis*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AnyAxesHovered": [
+    {
+      "args": "(ImPlotAxis* axes,int count)",
+      "argsT": [
+        {
+          "name": "axes",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis* axes,int count)",
+      "call_args": "(axes,count)",
+      "cimguiname": "ImPlot_AnyAxesHovered",
+      "defaults": {},
+      "funcname": "AnyAxesHovered",
+      "location": "implot_internal:1371",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AnyAxesHovered",
+      "ret": "bool",
+      "signature": "(ImPlotAxis*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_AnyAxesInputLocked": [
+    {
+      "args": "(ImPlotAxis* axes,int count)",
+      "argsT": [
+        {
+          "name": "axes",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis* axes,int count)",
+      "call_args": "(axes,count)",
+      "cimguiname": "ImPlot_AnyAxesInputLocked",
+      "defaults": {},
+      "funcname": "AnyAxesInputLocked",
+      "location": "implot_internal:1346",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_AnyAxesInputLocked",
+      "ret": "bool",
+      "signature": "(ImPlotAxis*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginAlignedPlots": [
+    {
+      "args": "(const char* group_id,bool vertical)",
+      "argsT": [
+        {
+          "name": "group_id",
+          "type": "const char*"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* group_id,bool vertical=true)",
+      "call_args": "(group_id,vertical)",
+      "cimguiname": "ImPlot_BeginAlignedPlots",
+      "defaults": {
+        "vertical": "true"
+      },
+      "funcname": "BeginAlignedPlots",
+      "location": "implot:997",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginAlignedPlots",
+      "ret": "bool",
+      "signature": "(const char*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginDragDropSourceAxis": [
+    {
+      "args": "(ImAxis axis,ImGuiDragDropFlags flags)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDragDropFlags"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,ImGuiDragDropFlags flags=0)",
+      "call_args": "(axis,flags)",
+      "cimguiname": "ImPlot_BeginDragDropSourceAxis",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginDragDropSourceAxis",
+      "location": "implot:1031",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginDragDropSourceAxis",
+      "ret": "bool",
+      "signature": "(ImAxis,ImGuiDragDropFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginDragDropSourceItem": [
+    {
+      "args": "(const char* label_id,ImGuiDragDropFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImGuiDragDropFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImGuiDragDropFlags flags=0)",
+      "call_args": "(label_id,flags)",
+      "cimguiname": "ImPlot_BeginDragDropSourceItem",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginDragDropSourceItem",
+      "location": "implot:1033",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginDragDropSourceItem",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiDragDropFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginDragDropSourcePlot": [
+    {
+      "args": "(ImGuiDragDropFlags flags)",
+      "argsT": [
+        {
+          "name": "flags",
+          "type": "ImGuiDragDropFlags"
+        }
+      ],
+      "argsoriginal": "(ImGuiDragDropFlags flags=0)",
+      "call_args": "(flags)",
+      "cimguiname": "ImPlot_BeginDragDropSourcePlot",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "BeginDragDropSourcePlot",
+      "location": "implot:1029",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginDragDropSourcePlot",
+      "ret": "bool",
+      "signature": "(ImGuiDragDropFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginDragDropTargetAxis": [
+    {
+      "args": "(ImAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "ImPlot_BeginDragDropTargetAxis",
+      "defaults": {},
+      "funcname": "BeginDragDropTargetAxis",
+      "location": "implot:1019",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginDragDropTargetAxis",
+      "ret": "bool",
+      "signature": "(ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginDragDropTargetLegend": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_BeginDragDropTargetLegend",
+      "defaults": {},
+      "funcname": "BeginDragDropTargetLegend",
+      "location": "implot:1021",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginDragDropTargetLegend",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginDragDropTargetPlot": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_BeginDragDropTargetPlot",
+      "defaults": {},
+      "funcname": "BeginDragDropTargetPlot",
+      "location": "implot:1017",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginDragDropTargetPlot",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginItem": [
+    {
+      "args": "(const char* label_id,ImPlotItemFlags flags,ImPlotCol recolor_from)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotItemFlags"
+        },
+        {
+          "name": "recolor_from",
+          "type": "ImPlotCol"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotItemFlags flags=0,ImPlotCol recolor_from=-1)",
+      "call_args": "(label_id,flags,recolor_from)",
+      "cimguiname": "ImPlot_BeginItem",
+      "defaults": {
+        "flags": "0",
+        "recolor_from": "-1"
+      },
+      "funcname": "BeginItem",
+      "location": "implot_internal:1315",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginItem",
+      "ret": "bool",
+      "signature": "(const char*,ImPlotItemFlags,ImPlotCol)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginLegendPopup": [
+    {
+      "args": "(const char* label_id,ImGuiMouseButton mouse_button)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "mouse_button",
+          "type": "ImGuiMouseButton"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImGuiMouseButton mouse_button=1)",
+      "call_args": "(label_id,mouse_button)",
+      "cimguiname": "ImPlot_BeginLegendPopup",
+      "defaults": {
+        "mouse_button": "1"
+      },
+      "funcname": "BeginLegendPopup",
+      "location": "implot:1006",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginLegendPopup",
+      "ret": "bool",
+      "signature": "(const char*,ImGuiMouseButton)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginPlot": [
+    {
+      "args": "(const char* title_id,const ImVec2 size,ImPlotFlags flags)",
+      "argsT": [
+        {
+          "name": "title_id",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotFlags"
+        }
+      ],
+      "argsoriginal": "(const char* title_id,const ImVec2& size=ImVec2(-1,0),ImPlotFlags flags=0)",
+      "call_args": "(title_id,size,flags)",
+      "cimguiname": "ImPlot_BeginPlot",
+      "defaults": {
+        "flags": "0",
+        "size": "ImVec2(-1,0)"
+      },
+      "funcname": "BeginPlot",
+      "location": "implot:626",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginPlot",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,ImPlotFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BeginSubplots": [
+    {
+      "args": "(const char* title_id,int rows,int cols,const ImVec2 size,ImPlotSubplotFlags flags,float* row_ratios,float* col_ratios)",
+      "argsT": [
+        {
+          "name": "title_id",
+          "type": "const char*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotSubplotFlags"
+        },
+        {
+          "name": "row_ratios",
+          "type": "float*"
+        },
+        {
+          "name": "col_ratios",
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(const char* title_id,int rows,int cols,const ImVec2& size,ImPlotSubplotFlags flags=0,float* row_ratios=((void*)0),float* col_ratios=((void*)0))",
+      "call_args": "(title_id,rows,cols,size,flags,row_ratios,col_ratios)",
+      "cimguiname": "ImPlot_BeginSubplots",
+      "defaults": {
+        "col_ratios": "NULL",
+        "flags": "0",
+        "row_ratios": "NULL"
+      },
+      "funcname": "BeginSubplots",
+      "location": "implot:682",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BeginSubplots",
+      "ret": "bool",
+      "signature": "(const char*,int,int,const ImVec2,ImPlotSubplotFlags,float*,float*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BustColorCache": [
+    {
+      "args": "(const char* plot_title_id)",
+      "argsT": [
+        {
+          "name": "plot_title_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* plot_title_id=((void*)0))",
+      "call_args": "(plot_title_id)",
+      "cimguiname": "ImPlot_BustColorCache",
+      "defaults": {
+        "plot_title_id": "NULL"
+      },
+      "funcname": "BustColorCache",
+      "location": "implot:1187",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BustColorCache",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BustItemCache": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_BustItemCache",
+      "defaults": {},
+      "funcname": "BustItemCache",
+      "location": "implot_internal:1339",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BustItemCache",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_BustPlotCache": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_BustPlotCache",
+      "defaults": {},
+      "funcname": "BustPlotCache",
+      "location": "implot_internal:1284",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_BustPlotCache",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CalcHoverColor": [
+    {
+      "args": "(ImU32 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col)",
+      "call_args": "(col)",
+      "cimguiname": "ImPlot_CalcHoverColor",
+      "defaults": {},
+      "funcname": "CalcHoverColor",
+      "location": "implot_internal:1467",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalcHoverColor",
+      "ret": "ImU32",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CalcLegendSize": [
+    {
+      "args": "(ImVec2 *pOut,ImPlotItemGroup* items,const ImVec2 pad,const ImVec2 spacing,bool vertical)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "items",
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "pad",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "spacing",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImPlotItemGroup& items,const ImVec2& pad,const ImVec2& spacing,bool vertical)",
+      "call_args": "(*items,pad,spacing,vertical)",
+      "cimguiname": "ImPlot_CalcLegendSize",
+      "defaults": {},
+      "funcname": "CalcLegendSize",
+      "location": "implot_internal:1421",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_CalcLegendSize",
+      "ret": "void",
+      "signature": "(ImPlotItemGroup*,const ImVec2,const ImVec2,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CalcTextColor": [
+    {
+      "args": "(const ImVec4 bg)",
+      "argsT": [
+        {
+          "name": "bg",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& bg)",
+      "call_args": "(bg)",
+      "cimguiname": "ImPlot_CalcTextColor",
+      "defaults": {},
+      "funcname": "CalcTextColor",
+      "location": "implot_internal:1464",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalcTextColor_Vec4",
+      "ret": "ImU32",
+      "signature": "(const ImVec4)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU32 bg)",
+      "argsT": [
+        {
+          "name": "bg",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 bg)",
+      "call_args": "(bg)",
+      "cimguiname": "ImPlot_CalcTextColor",
+      "defaults": {},
+      "funcname": "CalcTextColor",
+      "location": "implot_internal:1465",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalcTextColor_U32",
+      "ret": "ImU32",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CalcTextSizeVertical": [
+    {
+      "args": "(ImVec2 *pOut,const char* text)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "text",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* text)",
+      "call_args": "(text)",
+      "cimguiname": "ImPlot_CalcTextSizeVertical",
+      "defaults": {},
+      "funcname": "CalcTextSizeVertical",
+      "location": "implot_internal:1459",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_CalcTextSizeVertical",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CalculateBins": [
+    {
+      "args": "(const float* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_FloatPtr",
+      "ret": "void",
+      "signature": "(const float*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_doublePtr",
+      "ret": "void",
+      "signature": "(const double*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_S8Ptr",
+      "ret": "void",
+      "signature": "(const ImS8*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_U8Ptr",
+      "ret": "void",
+      "signature": "(const ImU8*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_S16Ptr",
+      "ret": "void",
+      "signature": "(const ImS16*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_U16Ptr",
+      "ret": "void",
+      "signature": "(const ImU16*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_S32Ptr",
+      "ret": "void",
+      "signature": "(const ImS32*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_U32Ptr",
+      "ret": "void",
+      "signature": "(const ImU32*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_S64Ptr",
+      "ret": "void",
+      "signature": "(const ImS64*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count,ImPlotBin meth,const ImPlotRange range,int* bins_out,double* width_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "meth",
+          "type": "ImPlotBin"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "bins_out",
+          "reftoptr": true,
+          "type": "int*"
+        },
+        {
+          "name": "width_out",
+          "reftoptr": true,
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count,ImPlotBin meth,const ImPlotRange& range,int& bins_out,double& width_out)",
+      "call_args": "(values,count,meth,range,*bins_out,*width_out)",
+      "cimguiname": "ImPlot_CalculateBins",
+      "defaults": {},
+      "funcname": "CalculateBins",
+      "location": "implot_internal:1521",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CalculateBins_U64Ptr",
+      "ret": "void",
+      "signature": "(const ImU64*,int,ImPlotBin,const ImPlotRange,int*,double*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CancelPlotSelection": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_CancelPlotSelection",
+      "defaults": {},
+      "funcname": "CancelPlotSelection",
+      "location": "implot:984",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CancelPlotSelection",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CeilTime": [
+    {
+      "args": "(ImPlotTime *pOut,const ImPlotTime t,ImPlotTimeUnit unit)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "unit",
+          "type": "ImPlotTimeUnit"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,ImPlotTimeUnit unit)",
+      "call_args": "(t,unit)",
+      "cimguiname": "ImPlot_CeilTime",
+      "defaults": {},
+      "funcname": "CeilTime",
+      "location": "implot_internal:1579",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_CeilTime",
+      "ret": "void",
+      "signature": "(const ImPlotTime,ImPlotTimeUnit)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ClampLabelPos": [
+    {
+      "args": "(ImVec2 *pOut,ImVec2 pos,const ImVec2 size,const ImVec2 Min,const ImVec2 Max)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "pos",
+          "type": "ImVec2"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "Min",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "Max",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImVec2 pos,const ImVec2& size,const ImVec2& Min,const ImVec2& Max)",
+      "call_args": "(pos,size,Min,Max)",
+      "cimguiname": "ImPlot_ClampLabelPos",
+      "defaults": {},
+      "funcname": "ClampLabelPos",
+      "location": "implot_internal:1470",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_ClampLabelPos",
+      "ret": "void",
+      "signature": "(ImVec2,const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ColormapButton": [
+    {
+      "args": "(const char* label,const ImVec2 size,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(const char* label,const ImVec2& size=ImVec2(0,0),ImPlotColormap cmap=-1)",
+      "call_args": "(label,size,cmap)",
+      "cimguiname": "ImPlot_ColormapButton",
+      "defaults": {
+        "cmap": "-1",
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "ColormapButton",
+      "location": "implot:1178",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ColormapButton",
+      "ret": "bool",
+      "signature": "(const char*,const ImVec2,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ColormapIcon": [
+    {
+      "args": "(ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlot_ColormapIcon",
+      "defaults": {},
+      "funcname": "ColormapIcon",
+      "location": "implot:1208",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ColormapIcon",
+      "ret": "void",
+      "signature": "(ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ColormapScale": [
+    {
+      "args": "(const char* label,double scale_min,double scale_max,const ImVec2 size,const char* format,ImPlotColormapScaleFlags flags,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotColormapScaleFlags"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(const char* label,double scale_min,double scale_max,const ImVec2& size=ImVec2(0,0),const char* format=\"%g\",ImPlotColormapScaleFlags flags=0,ImPlotColormap cmap=-1)",
+      "call_args": "(label,scale_min,scale_max,size,format,flags,cmap)",
+      "cimguiname": "ImPlot_ColormapScale",
+      "defaults": {
+        "cmap": "-1",
+        "flags": "0",
+        "format": "\"%g\"",
+        "size": "ImVec2(0,0)"
+      },
+      "funcname": "ColormapScale",
+      "location": "implot:1174",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ColormapScale",
+      "ret": "void",
+      "signature": "(const char*,double,double,const ImVec2,const char*,ImPlotColormapScaleFlags,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ColormapSlider": [
+    {
+      "args": "(const char* label,float* t,ImVec4* out,const char* format,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "t",
+          "type": "float*"
+        },
+        {
+          "name": "out",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "format",
+          "type": "const char*"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(const char* label,float* t,ImVec4* out=((void*)0),const char* format=\"\",ImPlotColormap cmap=-1)",
+      "call_args": "(label,t,out,format,cmap)",
+      "cimguiname": "ImPlot_ColormapSlider",
+      "defaults": {
+        "cmap": "-1",
+        "format": "\"\"",
+        "out": "NULL"
+      },
+      "funcname": "ColormapSlider",
+      "location": "implot:1176",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ColormapSlider",
+      "ret": "bool",
+      "signature": "(const char*,float*,ImVec4*,const char*,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CombineDateTime": [
+    {
+      "args": "(ImPlotTime *pOut,const ImPlotTime date_part,const ImPlotTime time_part)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "date_part",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "time_part",
+          "type": "const ImPlotTime"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& date_part,const ImPlotTime& time_part)",
+      "call_args": "(date_part,time_part)",
+      "cimguiname": "ImPlot_CombineDateTime",
+      "defaults": {},
+      "funcname": "CombineDateTime",
+      "location": "implot_internal:1583",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_CombineDateTime",
+      "ret": "void",
+      "signature": "(const ImPlotTime,const ImPlotTime)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_CreateContext": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_CreateContext",
+      "defaults": {},
+      "funcname": "CreateContext",
+      "location": "implot:592",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_CreateContext",
+      "ret": "ImPlotContext*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_DestroyContext": [
+    {
+      "args": "(ImPlotContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImPlotContext*"
+        }
+      ],
+      "argsoriginal": "(ImPlotContext* ctx=((void*)0))",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_DestroyContext",
+      "defaults": {
+        "ctx": "NULL"
+      },
+      "funcname": "DestroyContext",
+      "location": "implot:594",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_DestroyContext",
+      "ret": "void",
+      "signature": "(ImPlotContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_DragLineX": [
+    {
+      "args": "(int id,double* x,const ImVec4 col,float thickness,ImPlotDragToolFlags flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double*"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDragToolFlags"
+        }
+      ],
+      "argsoriginal": "(int id,double* x,const ImVec4& col,float thickness=1,ImPlotDragToolFlags flags=0)",
+      "call_args": "(id,x,col,thickness,flags)",
+      "cimguiname": "ImPlot_DragLineX",
+      "defaults": {
+        "flags": "0",
+        "thickness": "1"
+      },
+      "funcname": "DragLineX",
+      "location": "implot:925",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_DragLineX",
+      "ret": "bool",
+      "signature": "(int,double*,const ImVec4,float,ImPlotDragToolFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_DragLineY": [
+    {
+      "args": "(int id,double* y,const ImVec4 col,float thickness,ImPlotDragToolFlags flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "y",
+          "type": "double*"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "thickness",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDragToolFlags"
+        }
+      ],
+      "argsoriginal": "(int id,double* y,const ImVec4& col,float thickness=1,ImPlotDragToolFlags flags=0)",
+      "call_args": "(id,y,col,thickness,flags)",
+      "cimguiname": "ImPlot_DragLineY",
+      "defaults": {
+        "flags": "0",
+        "thickness": "1"
+      },
+      "funcname": "DragLineY",
+      "location": "implot:927",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_DragLineY",
+      "ret": "bool",
+      "signature": "(int,double*,const ImVec4,float,ImPlotDragToolFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_DragPoint": [
+    {
+      "args": "(int id,double* x,double* y,const ImVec4 col,float size,ImPlotDragToolFlags flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double*"
+        },
+        {
+          "name": "y",
+          "type": "double*"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDragToolFlags"
+        }
+      ],
+      "argsoriginal": "(int id,double* x,double* y,const ImVec4& col,float size=4,ImPlotDragToolFlags flags=0)",
+      "call_args": "(id,x,y,col,size,flags)",
+      "cimguiname": "ImPlot_DragPoint",
+      "defaults": {
+        "flags": "0",
+        "size": "4"
+      },
+      "funcname": "DragPoint",
+      "location": "implot:923",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_DragPoint",
+      "ret": "bool",
+      "signature": "(int,double*,double*,const ImVec4,float,ImPlotDragToolFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_DragRect": [
+    {
+      "args": "(int id,double* x1,double* y1,double* x2,double* y2,const ImVec4 col,ImPlotDragToolFlags flags)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "int"
+        },
+        {
+          "name": "x1",
+          "type": "double*"
+        },
+        {
+          "name": "y1",
+          "type": "double*"
+        },
+        {
+          "name": "x2",
+          "type": "double*"
+        },
+        {
+          "name": "y2",
+          "type": "double*"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDragToolFlags"
+        }
+      ],
+      "argsoriginal": "(int id,double* x1,double* y1,double* x2,double* y2,const ImVec4& col,ImPlotDragToolFlags flags=0)",
+      "call_args": "(id,x1,y1,x2,y2,col,flags)",
+      "cimguiname": "ImPlot_DragRect",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "DragRect",
+      "location": "implot:929",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_DragRect",
+      "ret": "bool",
+      "signature": "(int,double*,double*,double*,double*,const ImVec4,ImPlotDragToolFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndAlignedPlots": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndAlignedPlots",
+      "defaults": {},
+      "funcname": "EndAlignedPlots",
+      "location": "implot:999",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndAlignedPlots",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndDragDropSource": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndDragDropSource",
+      "defaults": {},
+      "funcname": "EndDragDropSource",
+      "location": "implot:1035",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndDragDropSource",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndDragDropTarget": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndDragDropTarget",
+      "defaults": {},
+      "funcname": "EndDragDropTarget",
+      "location": "implot:1023",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndDragDropTarget",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndItem",
+      "defaults": {},
+      "funcname": "EndItem",
+      "location": "implot_internal:1330",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndItem",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndLegendPopup": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndLegendPopup",
+      "defaults": {},
+      "funcname": "EndLegendPopup",
+      "location": "implot:1008",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndLegendPopup",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndPlot": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndPlot",
+      "defaults": {},
+      "funcname": "EndPlot",
+      "location": "implot:630",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndPlot",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_EndSubplots": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_EndSubplots",
+      "defaults": {},
+      "funcname": "EndSubplots",
+      "location": "implot:692",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_EndSubplots",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FillRange": [
+    {
+      "args": "(ImVector_float * buffer,int n,float vmin,float vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_float *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "float"
+        },
+        {
+          "name": "vmax",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImVector<float>& buffer,int n,float vmin,float vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_Float_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_float *,int,float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_double * buffer,int n,double vmin,double vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_double *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "double"
+        },
+        {
+          "name": "vmax",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(ImVector<double>& buffer,int n,double vmin,double vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_double_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_double *,int,double,double)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImS8 * buffer,int n,ImS8 vmin,ImS8 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImS8 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImS8"
+        },
+        {
+          "name": "vmax",
+          "type": "ImS8"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImS8>& buffer,int n,ImS8 vmin,ImS8 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_S8_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImS8 *,int,ImS8,ImS8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImU8 * buffer,int n,ImU8 vmin,ImU8 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImU8 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImU8"
+        },
+        {
+          "name": "vmax",
+          "type": "ImU8"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImU8>& buffer,int n,ImU8 vmin,ImU8 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_U8_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImU8 *,int,ImU8,ImU8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImS16 * buffer,int n,ImS16 vmin,ImS16 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImS16 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImS16"
+        },
+        {
+          "name": "vmax",
+          "type": "ImS16"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImS16>& buffer,int n,ImS16 vmin,ImS16 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_S16_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImS16 *,int,ImS16,ImS16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImU16 * buffer,int n,ImU16 vmin,ImU16 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImU16 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImU16"
+        },
+        {
+          "name": "vmax",
+          "type": "ImU16"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImU16>& buffer,int n,ImU16 vmin,ImU16 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_U16_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImU16 *,int,ImU16,ImU16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImS32 * buffer,int n,ImS32 vmin,ImS32 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImS32 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImS32"
+        },
+        {
+          "name": "vmax",
+          "type": "ImS32"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImS32>& buffer,int n,ImS32 vmin,ImS32 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_S32_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImS32 *,int,ImS32,ImS32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImU32 * buffer,int n,ImU32 vmin,ImU32 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImU32 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImU32"
+        },
+        {
+          "name": "vmax",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImU32>& buffer,int n,ImU32 vmin,ImU32 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_U32_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImU32 *,int,ImU32,ImU32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImS64 * buffer,int n,ImS64 vmin,ImS64 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImS64 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImS64"
+        },
+        {
+          "name": "vmax",
+          "type": "ImS64"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImS64>& buffer,int n,ImS64 vmin,ImS64 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_S64_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImS64 *,int,ImS64,ImS64)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVector_ImU64 * buffer,int n,ImU64 vmin,ImU64 vmax)",
+      "argsT": [
+        {
+          "name": "buffer",
+          "reftoptr": true,
+          "type": "ImVector_ImU64 *"
+        },
+        {
+          "name": "n",
+          "type": "int"
+        },
+        {
+          "name": "vmin",
+          "type": "ImU64"
+        },
+        {
+          "name": "vmax",
+          "type": "ImU64"
+        }
+      ],
+      "argsoriginal": "(ImVector<ImU64>& buffer,int n,ImU64 vmin,ImU64 vmax)",
+      "call_args": "(*buffer,n,vmin,vmax)",
+      "cimguiname": "ImPlot_FillRange",
+      "defaults": {},
+      "funcname": "FillRange",
+      "location": "implot_internal:1511",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FillRange_Vector_U64_Ptr",
+      "ret": "void",
+      "signature": "(ImVector_ImU64 *,int,ImU64,ImU64)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FitPoint": [
+    {
+      "args": "(const ImPlotPoint p)",
+      "argsT": [
+        {
+          "name": "p",
+          "type": "const ImPlotPoint"
+        }
+      ],
+      "argsoriginal": "(const ImPlotPoint& p)",
+      "call_args": "(p)",
+      "cimguiname": "ImPlot_FitPoint",
+      "defaults": {},
+      "funcname": "FitPoint",
+      "location": "implot_internal:1399",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FitPoint",
+      "ret": "void",
+      "signature": "(const ImPlotPoint)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FitPointX": [
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_FitPointX",
+      "defaults": {},
+      "funcname": "FitPointX",
+      "location": "implot_internal:1385",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FitPointX",
+      "ret": "void",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FitPointY": [
+    {
+      "args": "(double y)",
+      "argsT": [
+        {
+          "name": "y",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double y)",
+      "call_args": "(y)",
+      "cimguiname": "ImPlot_FitPointY",
+      "defaults": {},
+      "funcname": "FitPointY",
+      "location": "implot_internal:1392",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FitPointY",
+      "ret": "void",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FitThisFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_FitThisFrame",
+      "defaults": {},
+      "funcname": "FitThisFrame",
+      "location": "implot_internal:1380",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FitThisFrame",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FloorTime": [
+    {
+      "args": "(ImPlotTime *pOut,const ImPlotTime t,ImPlotTimeUnit unit)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "unit",
+          "type": "ImPlotTimeUnit"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,ImPlotTimeUnit unit)",
+      "call_args": "(t,unit)",
+      "cimguiname": "ImPlot_FloorTime",
+      "defaults": {},
+      "funcname": "FloorTime",
+      "location": "implot_internal:1577",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_FloorTime",
+      "ret": "void",
+      "signature": "(const ImPlotTime,ImPlotTimeUnit)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FormatDate": [
+    {
+      "args": "(const ImPlotTime t,char* buffer,int size,ImPlotDateFmt fmt,bool use_iso_8601)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "buffer",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "fmt",
+          "type": "ImPlotDateFmt"
+        },
+        {
+          "name": "use_iso_8601",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,char* buffer,int size,ImPlotDateFmt fmt,bool use_iso_8601)",
+      "call_args": "(t,buffer,size,fmt,use_iso_8601)",
+      "cimguiname": "ImPlot_FormatDate",
+      "defaults": {},
+      "funcname": "FormatDate",
+      "location": "implot_internal:1588",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FormatDate",
+      "ret": "int",
+      "signature": "(const ImPlotTime,char*,int,ImPlotDateFmt,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FormatDateTime": [
+    {
+      "args": "(const ImPlotTime t,char* buffer,int size,ImPlotDateTimeSpec fmt)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "buffer",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "fmt",
+          "type": "ImPlotDateTimeSpec"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,char* buffer,int size,ImPlotDateTimeSpec fmt)",
+      "call_args": "(t,buffer,size,fmt)",
+      "cimguiname": "ImPlot_FormatDateTime",
+      "defaults": {},
+      "funcname": "FormatDateTime",
+      "location": "implot_internal:1590",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FormatDateTime",
+      "ret": "int",
+      "signature": "(const ImPlotTime,char*,int,ImPlotDateTimeSpec)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_FormatTime": [
+    {
+      "args": "(const ImPlotTime t,char* buffer,int size,ImPlotTimeFmt fmt,bool use_24_hr_clk)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "buffer",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "fmt",
+          "type": "ImPlotTimeFmt"
+        },
+        {
+          "name": "use_24_hr_clk",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,char* buffer,int size,ImPlotTimeFmt fmt,bool use_24_hr_clk)",
+      "call_args": "(t,buffer,size,fmt,use_24_hr_clk)",
+      "cimguiname": "ImPlot_FormatTime",
+      "defaults": {},
+      "funcname": "FormatTime",
+      "location": "implot_internal:1586",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_FormatTime",
+      "ret": "int",
+      "signature": "(const ImPlotTime,char*,int,ImPlotTimeFmt,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Formatter_Default": [
+    {
+      "args": "(double value,char* buff,int size,void* data)",
+      "argsT": [
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "buff",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double value,char* buff,int size,void* data)",
+      "call_args": "(value,buff,size,data)",
+      "cimguiname": "ImPlot_Formatter_Default",
+      "defaults": {},
+      "funcname": "Formatter_Default",
+      "location": "implot_internal:1635",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Formatter_Default",
+      "ret": "int",
+      "signature": "(double,char*,int,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Formatter_Logit": [
+    {
+      "args": "(double value,char* buff,int size,void* noname1)",
+      "argsT": [
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "buff",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double value,char* buff,int size,void*)",
+      "call_args": "(value,buff,size,noname1)",
+      "cimguiname": "ImPlot_Formatter_Logit",
+      "defaults": {},
+      "funcname": "Formatter_Logit",
+      "location": "implot_internal:1640",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Formatter_Logit",
+      "ret": "int",
+      "signature": "(double,char*,int,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Formatter_Time": [
+    {
+      "args": "(double noname1,char* buff,int size,void* data)",
+      "argsT": [
+        {
+          "name": "noname1",
+          "type": "double"
+        },
+        {
+          "name": "buff",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double,char* buff,int size,void* data)",
+      "call_args": "(noname1,buff,size,data)",
+      "cimguiname": "ImPlot_Formatter_Time",
+      "defaults": {},
+      "funcname": "Formatter_Time",
+      "location": "implot_internal:1656",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Formatter_Time",
+      "ret": "int",
+      "signature": "(double,char*,int,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetAutoColor": [
+    {
+      "args": "(ImVec4 *pOut,ImPlotCol idx)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlot_GetAutoColor",
+      "defaults": {},
+      "funcname": "GetAutoColor",
+      "location": "implot_internal:1448",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetAutoColor",
+      "ret": "void",
+      "signature": "(ImPlotCol)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetColormapColor": [
+    {
+      "args": "(ImVec4 *pOut,int idx,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "idx",
+          "type": "int"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(int idx,ImPlotColormap cmap=-1)",
+      "call_args": "(idx,cmap)",
+      "cimguiname": "ImPlot_GetColormapColor",
+      "defaults": {
+        "cmap": "-1"
+      },
+      "funcname": "GetColormapColor",
+      "location": "implot:1169",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetColormapColor",
+      "ret": "void",
+      "signature": "(int,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetColormapColorU32": [
+    {
+      "args": "(int idx,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "int"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(int idx,ImPlotColormap cmap)",
+      "call_args": "(idx,cmap)",
+      "cimguiname": "ImPlot_GetColormapColorU32",
+      "defaults": {},
+      "funcname": "GetColormapColorU32",
+      "location": "implot_internal:1479",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetColormapColorU32",
+      "ret": "ImU32",
+      "signature": "(int,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetColormapCount": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetColormapCount",
+      "defaults": {},
+      "funcname": "GetColormapCount",
+      "location": "implot:1146",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetColormapCount",
+      "ret": "int",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetColormapIndex": [
+    {
+      "args": "(const char* name)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "ImPlot_GetColormapIndex",
+      "defaults": {},
+      "funcname": "GetColormapIndex",
+      "location": "implot:1150",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetColormapIndex",
+      "ret": "ImPlotColormap",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetColormapName": [
+    {
+      "args": "(ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlot_GetColormapName",
+      "defaults": {},
+      "funcname": "GetColormapName",
+      "location": "implot:1148",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetColormapName",
+      "ret": "const char*",
+      "signature": "(ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetColormapSize": [
+    {
+      "args": "(ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap=-1)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlot_GetColormapSize",
+      "defaults": {
+        "cmap": "-1"
+      },
+      "funcname": "GetColormapSize",
+      "location": "implot:1167",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetColormapSize",
+      "ret": "int",
+      "signature": "(ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetCurrentContext": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetCurrentContext",
+      "defaults": {},
+      "funcname": "GetCurrentContext",
+      "location": "implot:596",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetCurrentContext",
+      "ret": "ImPlotContext*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetCurrentItem": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetCurrentItem",
+      "defaults": {},
+      "funcname": "GetCurrentItem",
+      "location": "implot_internal:1337",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetCurrentItem",
+      "ret": "ImPlotItem*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetCurrentPlot": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetCurrentPlot",
+      "defaults": {},
+      "funcname": "GetCurrentPlot",
+      "location": "implot_internal:1282",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetCurrentPlot",
+      "ret": "ImPlotPlot*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetDaysInMonth": [
+    {
+      "args": "(int year,int month)",
+      "argsT": [
+        {
+          "name": "year",
+          "type": "int"
+        },
+        {
+          "name": "month",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int year,int month)",
+      "call_args": "(year,month)",
+      "cimguiname": "ImPlot_GetDaysInMonth",
+      "defaults": {},
+      "funcname": "GetDaysInMonth",
+      "location": "implot_internal:1550",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetDaysInMonth",
+      "ret": "int",
+      "signature": "(int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetGmtTime": [
+    {
+      "args": "(const ImPlotTime t,tm* ptm)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "ptm",
+          "type": "tm*"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,tm* ptm)",
+      "call_args": "(t,ptm)",
+      "cimguiname": "ImPlot_GetGmtTime",
+      "defaults": {},
+      "funcname": "GetGmtTime",
+      "location": "implot_internal:1558",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetGmtTime",
+      "ret": "tm*",
+      "signature": "(const ImPlotTime,tm*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetInputMap": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetInputMap",
+      "defaults": {},
+      "funcname": "GetInputMap",
+      "location": "implot:1194",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetInputMap",
+      "ret": "ImPlotInputMap*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetItem": [
+    {
+      "args": "(const char* label_id)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label_id)",
+      "call_args": "(label_id)",
+      "cimguiname": "ImPlot_GetItem",
+      "defaults": {},
+      "funcname": "GetItem",
+      "location": "implot_internal:1335",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetItem",
+      "ret": "ImPlotItem*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetItemData": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetItemData",
+      "defaults": {},
+      "funcname": "GetItemData",
+      "location": "implot_internal:1441",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetItemData",
+      "ret": "const ImPlotNextItemData*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetLastItemColor": [
+    {
+      "args": "(ImVec4 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetLastItemColor",
+      "defaults": {},
+      "funcname": "GetLastItemColor",
+      "location": "implot:1116",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetLastItemColor",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetLocTime": [
+    {
+      "args": "(const ImPlotTime t,tm* ptm)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "ptm",
+          "type": "tm*"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,tm* ptm)",
+      "call_args": "(t,ptm)",
+      "cimguiname": "ImPlot_GetLocTime",
+      "defaults": {},
+      "funcname": "GetLocTime",
+      "location": "implot_internal:1563",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetLocTime",
+      "ret": "tm*",
+      "signature": "(const ImPlotTime,tm*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetLocationPos": [
+    {
+      "args": "(ImVec2 *pOut,const ImRect outer_rect,const ImVec2 inner_size,ImPlotLocation location,const ImVec2 pad)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "outer_rect",
+          "type": "const ImRect"
+        },
+        {
+          "name": "inner_size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "location",
+          "type": "ImPlotLocation"
+        },
+        {
+          "name": "pad",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImRect& outer_rect,const ImVec2& inner_size,ImPlotLocation location,const ImVec2& pad=ImVec2(0,0))",
+      "call_args": "(outer_rect,inner_size,location,pad)",
+      "cimguiname": "ImPlot_GetLocationPos",
+      "defaults": {
+        "pad": "ImVec2(0,0)"
+      },
+      "funcname": "GetLocationPos",
+      "location": "implot_internal:1419",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetLocationPos",
+      "ret": "void",
+      "signature": "(const ImRect,const ImVec2,ImPlotLocation,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetMarkerName": [
+    {
+      "args": "(ImPlotMarker idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotMarker"
+        }
+      ],
+      "argsoriginal": "(ImPlotMarker idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlot_GetMarkerName",
+      "defaults": {},
+      "funcname": "GetMarkerName",
+      "location": "implot:1121",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetMarkerName",
+      "ret": "const char*",
+      "signature": "(ImPlotMarker)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlot": [
+    {
+      "args": "(const char* title)",
+      "argsT": [
+        {
+          "name": "title",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* title)",
+      "call_args": "(title)",
+      "cimguiname": "ImPlot_GetPlot",
+      "defaults": {},
+      "funcname": "GetPlot",
+      "location": "implot_internal:1280",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetPlot",
+      "ret": "ImPlotPlot*",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlotDrawList": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetPlotDrawList",
+      "defaults": {},
+      "funcname": "GetPlotDrawList",
+      "location": "implot:1211",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetPlotDrawList",
+      "ret": "ImDrawList*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlotLimits": [
+    {
+      "args": "(ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(x_axis,y_axis)",
+      "cimguiname": "ImPlot_GetPlotLimits",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "GetPlotLimits",
+      "location": "implot:970",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetPlotLimits",
+      "ret": "ImPlotRect",
+      "signature": "(ImAxis,ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlotMousePos": [
+    {
+      "args": "(ImPlotPoint *pOut,ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(x_axis,y_axis)",
+      "cimguiname": "ImPlot_GetPlotMousePos",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "GetPlotMousePos",
+      "location": "implot:968",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetPlotMousePos",
+      "ret": "void",
+      "signature": "(ImAxis,ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlotPos": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetPlotPos",
+      "defaults": {},
+      "funcname": "GetPlotPos",
+      "location": "implot:963",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetPlotPos",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlotSelection": [
+    {
+      "args": "(ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(x_axis,y_axis)",
+      "cimguiname": "ImPlot_GetPlotSelection",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "GetPlotSelection",
+      "location": "implot:982",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetPlotSelection",
+      "ret": "ImPlotRect",
+      "signature": "(ImAxis,ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetPlotSize": [
+    {
+      "args": "(ImVec2 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetPlotSize",
+      "defaults": {},
+      "funcname": "GetPlotSize",
+      "location": "implot:965",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetPlotSize",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetStyle": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_GetStyle",
+      "defaults": {},
+      "funcname": "GetStyle",
+      "location": "implot:1071",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetStyle",
+      "ret": "ImPlotStyle*",
+      "retref": "&",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetStyleColorName": [
+    {
+      "args": "(ImPlotCol idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlot_GetStyleColorName",
+      "defaults": {},
+      "funcname": "GetStyleColorName",
+      "location": "implot:1119",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetStyleColorName",
+      "ret": "const char*",
+      "signature": "(ImPlotCol)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetStyleColorU32": [
+    {
+      "args": "(ImPlotCol idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlot_GetStyleColorU32",
+      "defaults": {},
+      "funcname": "GetStyleColorU32",
+      "location": "implot_internal:1452",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetStyleColorU32",
+      "ret": "ImU32",
+      "signature": "(ImPlotCol)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetStyleColorVec4": [
+    {
+      "args": "(ImVec4 *pOut,ImPlotCol idx)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlot_GetStyleColorVec4",
+      "defaults": {},
+      "funcname": "GetStyleColorVec4",
+      "location": "implot_internal:1451",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_GetStyleColorVec4",
+      "ret": "void",
+      "signature": "(ImPlotCol)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_GetYear": [
+    {
+      "args": "(const ImPlotTime t)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t)",
+      "call_args": "(t)",
+      "cimguiname": "ImPlot_GetYear",
+      "defaults": {},
+      "funcname": "GetYear",
+      "location": "implot_internal:1572",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_GetYear",
+      "ret": "int",
+      "signature": "(const ImPlotTime)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_HideNextItem": [
+    {
+      "args": "(bool hidden,ImPlotCond cond)",
+      "argsT": [
+        {
+          "name": "hidden",
+          "type": "bool"
+        },
+        {
+          "name": "cond",
+          "type": "ImPlotCond"
+        }
+      ],
+      "argsoriginal": "(bool hidden=true,ImPlotCond cond=ImPlotCond_Once)",
+      "call_args": "(hidden,cond)",
+      "cimguiname": "ImPlot_HideNextItem",
+      "defaults": {
+        "cond": "ImPlotCond_Once",
+        "hidden": "true"
+      },
+      "funcname": "HideNextItem",
+      "location": "implot:988",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_HideNextItem",
+      "ret": "void",
+      "signature": "(bool,ImPlotCond)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImAlmostEqual": [
+    {
+      "args": "(double v1,double v2,int ulp)",
+      "argsT": [
+        {
+          "name": "v1",
+          "type": "double"
+        },
+        {
+          "name": "v2",
+          "type": "double"
+        },
+        {
+          "name": "ulp",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(double v1,double v2,int ulp=2)",
+      "call_args": "(v1,v2,ulp)",
+      "cimguiname": "ImPlot_ImAlmostEqual",
+      "defaults": {
+        "ulp": "2"
+      },
+      "funcname": "ImAlmostEqual",
+      "location": "implot_internal:139",
+      "ov_cimguiname": "ImPlot_ImAlmostEqual",
+      "ret": "bool",
+      "signature": "(double,double,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImAlphaU32": [
+    {
+      "args": "(ImU32 col,float alpha)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        },
+        {
+          "name": "alpha",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImU32 col,float alpha)",
+      "call_args": "(col,alpha)",
+      "cimguiname": "ImPlot_ImAlphaU32",
+      "defaults": {},
+      "funcname": "ImAlphaU32",
+      "location": "implot_internal:219",
+      "ov_cimguiname": "ImPlot_ImAlphaU32",
+      "ret": "ImU32",
+      "signature": "(ImU32,float)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImAsinh": [
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_ImAsinh",
+      "defaults": {},
+      "funcname": "ImAsinh",
+      "location": "implot_internal:110",
+      "ov_cimguiname": "ImPlot_ImAsinh_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_ImAsinh",
+      "defaults": {},
+      "funcname": "ImAsinh",
+      "location": "implot_internal:111",
+      "ov_cimguiname": "ImPlot_ImAsinh_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImConstrainInf": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_ImConstrainInf",
+      "defaults": {},
+      "funcname": "ImConstrainInf",
+      "location": "implot_internal:133",
+      "ov_cimguiname": "ImPlot_ImConstrainInf",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImConstrainLog": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_ImConstrainLog",
+      "defaults": {},
+      "funcname": "ImConstrainLog",
+      "location": "implot_internal:135",
+      "ov_cimguiname": "ImPlot_ImConstrainLog",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImConstrainNan": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_ImConstrainNan",
+      "defaults": {},
+      "funcname": "ImConstrainNan",
+      "location": "implot_internal:131",
+      "ov_cimguiname": "ImPlot_ImConstrainNan",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImConstrainTime": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_ImConstrainTime",
+      "defaults": {},
+      "funcname": "ImConstrainTime",
+      "location": "implot_internal:137",
+      "ov_cimguiname": "ImPlot_ImConstrainTime",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImLerpU32": [
+    {
+      "args": "(const ImU32* colors,int size,float t)",
+      "argsT": [
+        {
+          "name": "colors",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImU32* colors,int size,float t)",
+      "call_args": "(colors,size,t)",
+      "cimguiname": "ImPlot_ImLerpU32",
+      "defaults": {},
+      "funcname": "ImLerpU32",
+      "location": "implot_internal:206",
+      "ov_cimguiname": "ImPlot_ImLerpU32",
+      "ret": "ImU32",
+      "signature": "(const ImU32*,int,float)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImLog10": [
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_ImLog10",
+      "defaults": {},
+      "funcname": "ImLog10",
+      "location": "implot_internal:106",
+      "ov_cimguiname": "ImPlot_ImLog10_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_ImLog10",
+      "defaults": {},
+      "funcname": "ImLog10",
+      "location": "implot_internal:107",
+      "ov_cimguiname": "ImPlot_ImLog10_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImMaxArray": [
+    {
+      "args": "(const float* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_FloatPtr",
+      "ret": "float",
+      "signature": "(const float*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_doublePtr",
+      "ret": "double",
+      "signature": "(const double*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_S8Ptr",
+      "ret": "ImS8",
+      "signature": "(const ImS8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_U8Ptr",
+      "ret": "ImU8",
+      "signature": "(const ImU8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_S16Ptr",
+      "ret": "ImS16",
+      "signature": "(const ImS16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_U16Ptr",
+      "ret": "ImU16",
+      "signature": "(const ImU16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_S32Ptr",
+      "ret": "ImS32",
+      "signature": "(const ImS32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_U32Ptr",
+      "ret": "ImU32",
+      "signature": "(const ImU32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_S64Ptr",
+      "ret": "ImS64",
+      "signature": "(const ImS64*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMaxArray",
+      "defaults": {},
+      "funcname": "ImMaxArray",
+      "location": "implot_internal:144",
+      "ov_cimguiname": "ImPlot_ImMaxArray_U64Ptr",
+      "ret": "ImU64",
+      "signature": "(const ImU64*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImMean": [
+    {
+      "args": "(const float* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_FloatPtr",
+      "ret": "double",
+      "signature": "(const float*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_doublePtr",
+      "ret": "double",
+      "signature": "(const double*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_S8Ptr",
+      "ret": "double",
+      "signature": "(const ImS8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_U8Ptr",
+      "ret": "double",
+      "signature": "(const ImU8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_S16Ptr",
+      "ret": "double",
+      "signature": "(const ImS16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_U16Ptr",
+      "ret": "double",
+      "signature": "(const ImU16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_S32Ptr",
+      "ret": "double",
+      "signature": "(const ImS32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_U32Ptr",
+      "ret": "double",
+      "signature": "(const ImU32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_S64Ptr",
+      "ret": "double",
+      "signature": "(const ImS64*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMean",
+      "defaults": {},
+      "funcname": "ImMean",
+      "location": "implot_internal:165",
+      "ov_cimguiname": "ImPlot_ImMean_U64Ptr",
+      "ret": "double",
+      "signature": "(const ImU64*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImMinArray": [
+    {
+      "args": "(const float* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_FloatPtr",
+      "ret": "float",
+      "signature": "(const float*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_doublePtr",
+      "ret": "double",
+      "signature": "(const double*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_S8Ptr",
+      "ret": "ImS8",
+      "signature": "(const ImS8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_U8Ptr",
+      "ret": "ImU8",
+      "signature": "(const ImU8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_S16Ptr",
+      "ret": "ImS16",
+      "signature": "(const ImS16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_U16Ptr",
+      "ret": "ImU16",
+      "signature": "(const ImU16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_S32Ptr",
+      "ret": "ImS32",
+      "signature": "(const ImS32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_U32Ptr",
+      "ret": "ImU32",
+      "signature": "(const ImU32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_S64Ptr",
+      "ret": "ImS64",
+      "signature": "(const ImS64*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImMinArray",
+      "defaults": {},
+      "funcname": "ImMinArray",
+      "location": "implot_internal:141",
+      "ov_cimguiname": "ImPlot_ImMinArray_U64Ptr",
+      "ret": "ImU64",
+      "signature": "(const ImU64*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImMinMaxArray": [
+    {
+      "args": "(const float* values,int count,float* min_out,float* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "float*"
+        },
+        {
+          "name": "max_out",
+          "type": "float*"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count,float* min_out,float* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_FloatPtr",
+      "ret": "void",
+      "signature": "(const float*,int,float*,float*)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count,double* min_out,double* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "double*"
+        },
+        {
+          "name": "max_out",
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count,double* min_out,double* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_doublePtr",
+      "ret": "void",
+      "signature": "(const double*,int,double*,double*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count,ImS8* min_out,ImS8* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImS8*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImS8*"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count,ImS8* min_out,ImS8* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_S8Ptr",
+      "ret": "void",
+      "signature": "(const ImS8*,int,ImS8*,ImS8*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count,ImU8* min_out,ImU8* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImU8*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImU8*"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count,ImU8* min_out,ImU8* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_U8Ptr",
+      "ret": "void",
+      "signature": "(const ImU8*,int,ImU8*,ImU8*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count,ImS16* min_out,ImS16* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImS16*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImS16*"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count,ImS16* min_out,ImS16* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_S16Ptr",
+      "ret": "void",
+      "signature": "(const ImS16*,int,ImS16*,ImS16*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count,ImU16* min_out,ImU16* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImU16*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImU16*"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count,ImU16* min_out,ImU16* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_U16Ptr",
+      "ret": "void",
+      "signature": "(const ImU16*,int,ImU16*,ImU16*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count,ImS32* min_out,ImS32* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImS32*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImS32*"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count,ImS32* min_out,ImS32* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_S32Ptr",
+      "ret": "void",
+      "signature": "(const ImS32*,int,ImS32*,ImS32*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count,ImU32* min_out,ImU32* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImU32*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImU32*"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count,ImU32* min_out,ImU32* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_U32Ptr",
+      "ret": "void",
+      "signature": "(const ImU32*,int,ImU32*,ImU32*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count,ImS64* min_out,ImS64* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImS64*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImS64*"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count,ImS64* min_out,ImS64* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_S64Ptr",
+      "ret": "void",
+      "signature": "(const ImS64*,int,ImS64*,ImS64*)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count,ImU64* min_out,ImU64* max_out)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "min_out",
+          "type": "ImU64*"
+        },
+        {
+          "name": "max_out",
+          "type": "ImU64*"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count,ImU64* min_out,ImU64* max_out)",
+      "call_args": "(values,count,min_out,max_out)",
+      "cimguiname": "ImPlot_ImMinMaxArray",
+      "defaults": {},
+      "funcname": "ImMinMaxArray",
+      "location": "implot_internal:147",
+      "ov_cimguiname": "ImPlot_ImMinMaxArray_U64Ptr",
+      "ret": "void",
+      "signature": "(const ImU64*,int,ImU64*,ImU64*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImMixU32": [
+    {
+      "args": "(ImU32 a,ImU32 b,ImU32 s)",
+      "argsT": [
+        {
+          "name": "a",
+          "type": "ImU32"
+        },
+        {
+          "name": "b",
+          "type": "ImU32"
+        },
+        {
+          "name": "s",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 a,ImU32 b,ImU32 s)",
+      "call_args": "(a,b,s)",
+      "cimguiname": "ImPlot_ImMixU32",
+      "defaults": {},
+      "funcname": "ImMixU32",
+      "location": "implot_internal:184",
+      "ov_cimguiname": "ImPlot_ImMixU32",
+      "ret": "ImU32",
+      "signature": "(ImU32,ImU32,ImU32)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImNan": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_ImNan",
+      "defaults": {},
+      "funcname": "ImNan",
+      "location": "implot_internal:127",
+      "ov_cimguiname": "ImPlot_ImNan",
+      "ret": "bool",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImNanOrInf": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_ImNanOrInf",
+      "defaults": {},
+      "funcname": "ImNanOrInf",
+      "location": "implot_internal:129",
+      "ov_cimguiname": "ImPlot_ImNanOrInf",
+      "ret": "bool",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImOverlaps": [
+    {
+      "args": "(float min_a,float max_a,float min_b,float max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "float"
+        },
+        {
+          "name": "max_a",
+          "type": "float"
+        },
+        {
+          "name": "min_b",
+          "type": "float"
+        },
+        {
+          "name": "max_b",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float min_a,float max_a,float min_b,float max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_Float",
+      "ret": "bool",
+      "signature": "(float,float,float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(double min_a,double max_a,double min_b,double max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "double"
+        },
+        {
+          "name": "max_a",
+          "type": "double"
+        },
+        {
+          "name": "min_b",
+          "type": "double"
+        },
+        {
+          "name": "max_b",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double min_a,double max_a,double min_b,double max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_double",
+      "ret": "bool",
+      "signature": "(double,double,double,double)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS8 min_a,ImS8 max_a,ImS8 min_b,ImS8 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImS8"
+        },
+        {
+          "name": "max_a",
+          "type": "ImS8"
+        },
+        {
+          "name": "min_b",
+          "type": "ImS8"
+        },
+        {
+          "name": "max_b",
+          "type": "ImS8"
+        }
+      ],
+      "argsoriginal": "(ImS8 min_a,ImS8 max_a,ImS8 min_b,ImS8 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_S8",
+      "ret": "bool",
+      "signature": "(ImS8,ImS8,ImS8,ImS8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU8 min_a,ImU8 max_a,ImU8 min_b,ImU8 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImU8"
+        },
+        {
+          "name": "max_a",
+          "type": "ImU8"
+        },
+        {
+          "name": "min_b",
+          "type": "ImU8"
+        },
+        {
+          "name": "max_b",
+          "type": "ImU8"
+        }
+      ],
+      "argsoriginal": "(ImU8 min_a,ImU8 max_a,ImU8 min_b,ImU8 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_U8",
+      "ret": "bool",
+      "signature": "(ImU8,ImU8,ImU8,ImU8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS16 min_a,ImS16 max_a,ImS16 min_b,ImS16 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImS16"
+        },
+        {
+          "name": "max_a",
+          "type": "ImS16"
+        },
+        {
+          "name": "min_b",
+          "type": "ImS16"
+        },
+        {
+          "name": "max_b",
+          "type": "ImS16"
+        }
+      ],
+      "argsoriginal": "(ImS16 min_a,ImS16 max_a,ImS16 min_b,ImS16 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_S16",
+      "ret": "bool",
+      "signature": "(ImS16,ImS16,ImS16,ImS16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU16 min_a,ImU16 max_a,ImU16 min_b,ImU16 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImU16"
+        },
+        {
+          "name": "max_a",
+          "type": "ImU16"
+        },
+        {
+          "name": "min_b",
+          "type": "ImU16"
+        },
+        {
+          "name": "max_b",
+          "type": "ImU16"
+        }
+      ],
+      "argsoriginal": "(ImU16 min_a,ImU16 max_a,ImU16 min_b,ImU16 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_U16",
+      "ret": "bool",
+      "signature": "(ImU16,ImU16,ImU16,ImU16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS32 min_a,ImS32 max_a,ImS32 min_b,ImS32 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImS32"
+        },
+        {
+          "name": "max_a",
+          "type": "ImS32"
+        },
+        {
+          "name": "min_b",
+          "type": "ImS32"
+        },
+        {
+          "name": "max_b",
+          "type": "ImS32"
+        }
+      ],
+      "argsoriginal": "(ImS32 min_a,ImS32 max_a,ImS32 min_b,ImS32 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_S32",
+      "ret": "bool",
+      "signature": "(ImS32,ImS32,ImS32,ImS32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU32 min_a,ImU32 max_a,ImU32 min_b,ImU32 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImU32"
+        },
+        {
+          "name": "max_a",
+          "type": "ImU32"
+        },
+        {
+          "name": "min_b",
+          "type": "ImU32"
+        },
+        {
+          "name": "max_b",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 min_a,ImU32 max_a,ImU32 min_b,ImU32 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_U32",
+      "ret": "bool",
+      "signature": "(ImU32,ImU32,ImU32,ImU32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS64 min_a,ImS64 max_a,ImS64 min_b,ImS64 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImS64"
+        },
+        {
+          "name": "max_a",
+          "type": "ImS64"
+        },
+        {
+          "name": "min_b",
+          "type": "ImS64"
+        },
+        {
+          "name": "max_b",
+          "type": "ImS64"
+        }
+      ],
+      "argsoriginal": "(ImS64 min_a,ImS64 max_a,ImS64 min_b,ImS64 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_S64",
+      "ret": "bool",
+      "signature": "(ImS64,ImS64,ImS64,ImS64)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU64 min_a,ImU64 max_a,ImU64 min_b,ImU64 max_b)",
+      "argsT": [
+        {
+          "name": "min_a",
+          "type": "ImU64"
+        },
+        {
+          "name": "max_a",
+          "type": "ImU64"
+        },
+        {
+          "name": "min_b",
+          "type": "ImU64"
+        },
+        {
+          "name": "max_b",
+          "type": "ImU64"
+        }
+      ],
+      "argsoriginal": "(ImU64 min_a,ImU64 max_a,ImU64 min_b,ImU64 max_b)",
+      "call_args": "(min_a,max_a,min_b,max_b)",
+      "cimguiname": "ImPlot_ImOverlaps",
+      "defaults": {},
+      "funcname": "ImOverlaps",
+      "location": "implot_internal:224",
+      "ov_cimguiname": "ImPlot_ImOverlaps_U64",
+      "ret": "bool",
+      "signature": "(ImU64,ImU64,ImU64,ImU64)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImPosMod": [
+    {
+      "args": "(int l,int r)",
+      "argsT": [
+        {
+          "name": "l",
+          "type": "int"
+        },
+        {
+          "name": "r",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int l,int r)",
+      "call_args": "(l,r)",
+      "cimguiname": "ImPlot_ImPosMod",
+      "defaults": {},
+      "funcname": "ImPosMod",
+      "location": "implot_internal:125",
+      "ov_cimguiname": "ImPlot_ImPosMod",
+      "ret": "int",
+      "signature": "(int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImRemap": [
+    {
+      "args": "(float x,float x0,float x1,float y0,float y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        },
+        {
+          "name": "x0",
+          "type": "float"
+        },
+        {
+          "name": "x1",
+          "type": "float"
+        },
+        {
+          "name": "y0",
+          "type": "float"
+        },
+        {
+          "name": "y1",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x,float x0,float x1,float y0,float y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_Float",
+      "ret": "float",
+      "signature": "(float,float,float,float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x,double x0,double x1,double y0,double y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "x0",
+          "type": "double"
+        },
+        {
+          "name": "x1",
+          "type": "double"
+        },
+        {
+          "name": "y0",
+          "type": "double"
+        },
+        {
+          "name": "y1",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x,double x0,double x1,double y0,double y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_double",
+      "ret": "double",
+      "signature": "(double,double,double,double,double)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS8 x,ImS8 x0,ImS8 x1,ImS8 y0,ImS8 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS8"
+        },
+        {
+          "name": "x0",
+          "type": "ImS8"
+        },
+        {
+          "name": "x1",
+          "type": "ImS8"
+        },
+        {
+          "name": "y0",
+          "type": "ImS8"
+        },
+        {
+          "name": "y1",
+          "type": "ImS8"
+        }
+      ],
+      "argsoriginal": "(ImS8 x,ImS8 x0,ImS8 x1,ImS8 y0,ImS8 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_S8",
+      "ret": "ImS8",
+      "signature": "(ImS8,ImS8,ImS8,ImS8,ImS8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU8 x,ImU8 x0,ImU8 x1,ImU8 y0,ImU8 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU8"
+        },
+        {
+          "name": "x0",
+          "type": "ImU8"
+        },
+        {
+          "name": "x1",
+          "type": "ImU8"
+        },
+        {
+          "name": "y0",
+          "type": "ImU8"
+        },
+        {
+          "name": "y1",
+          "type": "ImU8"
+        }
+      ],
+      "argsoriginal": "(ImU8 x,ImU8 x0,ImU8 x1,ImU8 y0,ImU8 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_U8",
+      "ret": "ImU8",
+      "signature": "(ImU8,ImU8,ImU8,ImU8,ImU8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS16 x,ImS16 x0,ImS16 x1,ImS16 y0,ImS16 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS16"
+        },
+        {
+          "name": "x0",
+          "type": "ImS16"
+        },
+        {
+          "name": "x1",
+          "type": "ImS16"
+        },
+        {
+          "name": "y0",
+          "type": "ImS16"
+        },
+        {
+          "name": "y1",
+          "type": "ImS16"
+        }
+      ],
+      "argsoriginal": "(ImS16 x,ImS16 x0,ImS16 x1,ImS16 y0,ImS16 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_S16",
+      "ret": "ImS16",
+      "signature": "(ImS16,ImS16,ImS16,ImS16,ImS16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU16 x,ImU16 x0,ImU16 x1,ImU16 y0,ImU16 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU16"
+        },
+        {
+          "name": "x0",
+          "type": "ImU16"
+        },
+        {
+          "name": "x1",
+          "type": "ImU16"
+        },
+        {
+          "name": "y0",
+          "type": "ImU16"
+        },
+        {
+          "name": "y1",
+          "type": "ImU16"
+        }
+      ],
+      "argsoriginal": "(ImU16 x,ImU16 x0,ImU16 x1,ImU16 y0,ImU16 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_U16",
+      "ret": "ImU16",
+      "signature": "(ImU16,ImU16,ImU16,ImU16,ImU16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS32 x,ImS32 x0,ImS32 x1,ImS32 y0,ImS32 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS32"
+        },
+        {
+          "name": "x0",
+          "type": "ImS32"
+        },
+        {
+          "name": "x1",
+          "type": "ImS32"
+        },
+        {
+          "name": "y0",
+          "type": "ImS32"
+        },
+        {
+          "name": "y1",
+          "type": "ImS32"
+        }
+      ],
+      "argsoriginal": "(ImS32 x,ImS32 x0,ImS32 x1,ImS32 y0,ImS32 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_S32",
+      "ret": "ImS32",
+      "signature": "(ImS32,ImS32,ImS32,ImS32,ImS32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU32 x,ImU32 x0,ImU32 x1,ImU32 y0,ImU32 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU32"
+        },
+        {
+          "name": "x0",
+          "type": "ImU32"
+        },
+        {
+          "name": "x1",
+          "type": "ImU32"
+        },
+        {
+          "name": "y0",
+          "type": "ImU32"
+        },
+        {
+          "name": "y1",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 x,ImU32 x0,ImU32 x1,ImU32 y0,ImU32 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_U32",
+      "ret": "ImU32",
+      "signature": "(ImU32,ImU32,ImU32,ImU32,ImU32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS64 x,ImS64 x0,ImS64 x1,ImS64 y0,ImS64 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS64"
+        },
+        {
+          "name": "x0",
+          "type": "ImS64"
+        },
+        {
+          "name": "x1",
+          "type": "ImS64"
+        },
+        {
+          "name": "y0",
+          "type": "ImS64"
+        },
+        {
+          "name": "y1",
+          "type": "ImS64"
+        }
+      ],
+      "argsoriginal": "(ImS64 x,ImS64 x0,ImS64 x1,ImS64 y0,ImS64 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_S64",
+      "ret": "ImS64",
+      "signature": "(ImS64,ImS64,ImS64,ImS64,ImS64)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU64 x,ImU64 x0,ImU64 x1,ImU64 y0,ImU64 y1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU64"
+        },
+        {
+          "name": "x0",
+          "type": "ImU64"
+        },
+        {
+          "name": "x1",
+          "type": "ImU64"
+        },
+        {
+          "name": "y0",
+          "type": "ImU64"
+        },
+        {
+          "name": "y1",
+          "type": "ImU64"
+        }
+      ],
+      "argsoriginal": "(ImU64 x,ImU64 x0,ImU64 x1,ImU64 y0,ImU64 y1)",
+      "call_args": "(x,x0,x1,y0,y1)",
+      "cimguiname": "ImPlot_ImRemap",
+      "defaults": {},
+      "funcname": "ImRemap",
+      "location": "implot_internal:119",
+      "ov_cimguiname": "ImPlot_ImRemap_U64",
+      "ret": "ImU64",
+      "signature": "(ImU64,ImU64,ImU64,ImU64,ImU64)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImRemap01": [
+    {
+      "args": "(float x,float x0,float x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        },
+        {
+          "name": "x0",
+          "type": "float"
+        },
+        {
+          "name": "x1",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x,float x0,float x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_Float",
+      "ret": "float",
+      "signature": "(float,float,float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x,double x0,double x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "x0",
+          "type": "double"
+        },
+        {
+          "name": "x1",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x,double x0,double x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_double",
+      "ret": "double",
+      "signature": "(double,double,double)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS8 x,ImS8 x0,ImS8 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS8"
+        },
+        {
+          "name": "x0",
+          "type": "ImS8"
+        },
+        {
+          "name": "x1",
+          "type": "ImS8"
+        }
+      ],
+      "argsoriginal": "(ImS8 x,ImS8 x0,ImS8 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_S8",
+      "ret": "ImS8",
+      "signature": "(ImS8,ImS8,ImS8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU8 x,ImU8 x0,ImU8 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU8"
+        },
+        {
+          "name": "x0",
+          "type": "ImU8"
+        },
+        {
+          "name": "x1",
+          "type": "ImU8"
+        }
+      ],
+      "argsoriginal": "(ImU8 x,ImU8 x0,ImU8 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_U8",
+      "ret": "ImU8",
+      "signature": "(ImU8,ImU8,ImU8)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS16 x,ImS16 x0,ImS16 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS16"
+        },
+        {
+          "name": "x0",
+          "type": "ImS16"
+        },
+        {
+          "name": "x1",
+          "type": "ImS16"
+        }
+      ],
+      "argsoriginal": "(ImS16 x,ImS16 x0,ImS16 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_S16",
+      "ret": "ImS16",
+      "signature": "(ImS16,ImS16,ImS16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU16 x,ImU16 x0,ImU16 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU16"
+        },
+        {
+          "name": "x0",
+          "type": "ImU16"
+        },
+        {
+          "name": "x1",
+          "type": "ImU16"
+        }
+      ],
+      "argsoriginal": "(ImU16 x,ImU16 x0,ImU16 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_U16",
+      "ret": "ImU16",
+      "signature": "(ImU16,ImU16,ImU16)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS32 x,ImS32 x0,ImS32 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS32"
+        },
+        {
+          "name": "x0",
+          "type": "ImS32"
+        },
+        {
+          "name": "x1",
+          "type": "ImS32"
+        }
+      ],
+      "argsoriginal": "(ImS32 x,ImS32 x0,ImS32 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_S32",
+      "ret": "ImS32",
+      "signature": "(ImS32,ImS32,ImS32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU32 x,ImU32 x0,ImU32 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU32"
+        },
+        {
+          "name": "x0",
+          "type": "ImU32"
+        },
+        {
+          "name": "x1",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 x,ImU32 x0,ImU32 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_U32",
+      "ret": "ImU32",
+      "signature": "(ImU32,ImU32,ImU32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImS64 x,ImS64 x0,ImS64 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImS64"
+        },
+        {
+          "name": "x0",
+          "type": "ImS64"
+        },
+        {
+          "name": "x1",
+          "type": "ImS64"
+        }
+      ],
+      "argsoriginal": "(ImS64 x,ImS64 x0,ImS64 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_S64",
+      "ret": "ImS64",
+      "signature": "(ImS64,ImS64,ImS64)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU64 x,ImU64 x0,ImU64 x1)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "ImU64"
+        },
+        {
+          "name": "x0",
+          "type": "ImU64"
+        },
+        {
+          "name": "x1",
+          "type": "ImU64"
+        }
+      ],
+      "argsoriginal": "(ImU64 x,ImU64 x0,ImU64 x1)",
+      "call_args": "(x,x0,x1)",
+      "cimguiname": "ImPlot_ImRemap01",
+      "defaults": {},
+      "funcname": "ImRemap01",
+      "location": "implot_internal:122",
+      "ov_cimguiname": "ImPlot_ImRemap01_U64",
+      "ret": "ImU64",
+      "signature": "(ImU64,ImU64,ImU64)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImSinh": [
+    {
+      "args": "(float x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_ImSinh",
+      "defaults": {},
+      "funcname": "ImSinh",
+      "location": "implot_internal:108",
+      "ov_cimguiname": "ImPlot_ImSinh_Float",
+      "ret": "float",
+      "signature": "(float)",
+      "stname": ""
+    },
+    {
+      "args": "(double x)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double x)",
+      "call_args": "(x)",
+      "cimguiname": "ImPlot_ImSinh",
+      "defaults": {},
+      "funcname": "ImSinh",
+      "location": "implot_internal:109",
+      "ov_cimguiname": "ImPlot_ImSinh_double",
+      "ret": "double",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImStdDev": [
+    {
+      "args": "(const float* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_FloatPtr",
+      "ret": "double",
+      "signature": "(const float*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_doublePtr",
+      "ret": "double",
+      "signature": "(const double*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_S8Ptr",
+      "ret": "double",
+      "signature": "(const ImS8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_U8Ptr",
+      "ret": "double",
+      "signature": "(const ImU8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_S16Ptr",
+      "ret": "double",
+      "signature": "(const ImS16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_U16Ptr",
+      "ret": "double",
+      "signature": "(const ImU16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_S32Ptr",
+      "ret": "double",
+      "signature": "(const ImS32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_U32Ptr",
+      "ret": "double",
+      "signature": "(const ImU32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_S64Ptr",
+      "ret": "double",
+      "signature": "(const ImS64*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImStdDev",
+      "defaults": {},
+      "funcname": "ImStdDev",
+      "location": "implot_internal:174",
+      "ov_cimguiname": "ImPlot_ImStdDev_U64Ptr",
+      "ret": "double",
+      "signature": "(const ImU64*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ImSum": [
+    {
+      "args": "(const float* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const float* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_FloatPtr",
+      "ret": "float",
+      "signature": "(const float*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const double* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const double* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_doublePtr",
+      "ret": "double",
+      "signature": "(const double*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_S8Ptr",
+      "ret": "ImS8",
+      "signature": "(const ImS8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU8* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU8* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_U8Ptr",
+      "ret": "ImU8",
+      "signature": "(const ImU8*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_S16Ptr",
+      "ret": "ImS16",
+      "signature": "(const ImS16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU16* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU16* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_U16Ptr",
+      "ret": "ImU16",
+      "signature": "(const ImU16*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_S32Ptr",
+      "ret": "ImS32",
+      "signature": "(const ImS32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU32* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU32* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_U32Ptr",
+      "ret": "ImU32",
+      "signature": "(const ImU32*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImS64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImS64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_S64Ptr",
+      "ret": "ImS64",
+      "signature": "(const ImS64*,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const ImU64* values,int count)",
+      "argsT": [
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const ImU64* values,int count)",
+      "call_args": "(values,count)",
+      "cimguiname": "ImPlot_ImSum",
+      "defaults": {},
+      "funcname": "ImSum",
+      "location": "implot_internal:157",
+      "ov_cimguiname": "ImPlot_ImSum_U64Ptr",
+      "ret": "ImU64",
+      "signature": "(const ImU64*,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Initialize": [
+    {
+      "args": "(ImPlotContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImPlotContext*"
+        }
+      ],
+      "argsoriginal": "(ImPlotContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_Initialize",
+      "defaults": {},
+      "funcname": "Initialize",
+      "location": "implot_internal:1267",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Initialize",
+      "ret": "void",
+      "signature": "(ImPlotContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Intersection": [
+    {
+      "args": "(ImVec2 *pOut,const ImVec2 a1,const ImVec2 a2,const ImVec2 b1,const ImVec2 b2)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "a1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "a2",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "b2",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& a1,const ImVec2& a2,const ImVec2& b1,const ImVec2& b2)",
+      "call_args": "(a1,a2,b1,b2)",
+      "cimguiname": "ImPlot_Intersection",
+      "defaults": {},
+      "funcname": "Intersection",
+      "location": "implot_internal:1504",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_Intersection",
+      "ret": "void",
+      "signature": "(const ImVec2,const ImVec2,const ImVec2,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsAxisHovered": [
+    {
+      "args": "(ImAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "ImPlot_IsAxisHovered",
+      "defaults": {},
+      "funcname": "IsAxisHovered",
+      "location": "implot:975",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsAxisHovered",
+      "ret": "bool",
+      "signature": "(ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsColorAuto": [
+    {
+      "args": "(const ImVec4 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col)",
+      "call_args": "(col)",
+      "cimguiname": "ImPlot_IsColorAuto",
+      "defaults": {},
+      "funcname": "IsColorAuto",
+      "location": "implot_internal:1444",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsColorAuto_Vec4",
+      "ret": "bool",
+      "signature": "(const ImVec4)",
+      "stname": ""
+    },
+    {
+      "args": "(ImPlotCol idx)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx)",
+      "call_args": "(idx)",
+      "cimguiname": "ImPlot_IsColorAuto",
+      "defaults": {},
+      "funcname": "IsColorAuto",
+      "location": "implot_internal:1446",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsColorAuto_PlotCol",
+      "ret": "bool",
+      "signature": "(ImPlotCol)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsLeapYear": [
+    {
+      "args": "(int year)",
+      "argsT": [
+        {
+          "name": "year",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int year)",
+      "call_args": "(year)",
+      "cimguiname": "ImPlot_IsLeapYear",
+      "defaults": {},
+      "funcname": "IsLeapYear",
+      "location": "implot_internal:1546",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsLeapYear",
+      "ret": "bool",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsLegendEntryHovered": [
+    {
+      "args": "(const char* label_id)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label_id)",
+      "call_args": "(label_id)",
+      "cimguiname": "ImPlot_IsLegendEntryHovered",
+      "defaults": {},
+      "funcname": "IsLegendEntryHovered",
+      "location": "implot:1010",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsLegendEntryHovered",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsPlotHovered": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_IsPlotHovered",
+      "defaults": {},
+      "funcname": "IsPlotHovered",
+      "location": "implot:973",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsPlotHovered",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsPlotSelected": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_IsPlotSelected",
+      "defaults": {},
+      "funcname": "IsPlotSelected",
+      "location": "implot:980",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsPlotSelected",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_IsSubplotsHovered": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_IsSubplotsHovered",
+      "defaults": {},
+      "funcname": "IsSubplotsHovered",
+      "location": "implot:977",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_IsSubplotsHovered",
+      "ret": "bool",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ItemIcon": [
+    {
+      "args": "(const ImVec4 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col)",
+      "call_args": "(col)",
+      "cimguiname": "ImPlot_ItemIcon",
+      "defaults": {},
+      "funcname": "ItemIcon",
+      "location": "implot:1206",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ItemIcon_Vec4",
+      "ret": "void",
+      "signature": "(const ImVec4)",
+      "stname": ""
+    },
+    {
+      "args": "(ImU32 col)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImU32 col)",
+      "call_args": "(col)",
+      "cimguiname": "ImPlot_ItemIcon",
+      "defaults": {},
+      "funcname": "ItemIcon",
+      "location": "implot:1207",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ItemIcon_U32",
+      "ret": "void",
+      "signature": "(ImU32)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_LabelAxisValue": [
+    {
+      "args": "(const ImPlotAxis axis,double value,char* buff,int size,bool round)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "const ImPlotAxis"
+        },
+        {
+          "name": "value",
+          "type": "double"
+        },
+        {
+          "name": "buff",
+          "type": "char*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "round",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImPlotAxis& axis,double value,char* buff,int size,bool round=false)",
+      "call_args": "(axis,value,buff,size,round)",
+      "cimguiname": "ImPlot_LabelAxisValue",
+      "defaults": {
+        "round": "false"
+      },
+      "funcname": "LabelAxisValue",
+      "location": "implot_internal:1434",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_LabelAxisValue",
+      "ret": "void",
+      "signature": "(const ImPlotAxis,double,char*,int,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Locator_Default": [
+    {
+      "args": "(ImPlotTicker* ticker,const ImPlotRange range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "argsT": [
+        {
+          "name": "ticker",
+          "reftoptr": true,
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "pixels",
+          "type": "float"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        },
+        {
+          "name": "formatter",
+          "type": "ImPlotFormatter"
+        },
+        {
+          "name": "formatter_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImPlotTicker& ticker,const ImPlotRange& range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "call_args": "(*ticker,range,pixels,vertical,formatter,formatter_data)",
+      "cimguiname": "ImPlot_Locator_Default",
+      "defaults": {},
+      "funcname": "Locator_Default",
+      "location": "implot_internal:1665",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Locator_Default",
+      "ret": "void",
+      "signature": "(ImPlotTicker*,const ImPlotRange,float,bool,ImPlotFormatter,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Locator_Log10": [
+    {
+      "args": "(ImPlotTicker* ticker,const ImPlotRange range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "argsT": [
+        {
+          "name": "ticker",
+          "reftoptr": true,
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "pixels",
+          "type": "float"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        },
+        {
+          "name": "formatter",
+          "type": "ImPlotFormatter"
+        },
+        {
+          "name": "formatter_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImPlotTicker& ticker,const ImPlotRange& range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "call_args": "(*ticker,range,pixels,vertical,formatter,formatter_data)",
+      "cimguiname": "ImPlot_Locator_Log10",
+      "defaults": {},
+      "funcname": "Locator_Log10",
+      "location": "implot_internal:1667",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Locator_Log10",
+      "ret": "void",
+      "signature": "(ImPlotTicker*,const ImPlotRange,float,bool,ImPlotFormatter,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Locator_SymLog": [
+    {
+      "args": "(ImPlotTicker* ticker,const ImPlotRange range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "argsT": [
+        {
+          "name": "ticker",
+          "reftoptr": true,
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "pixels",
+          "type": "float"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        },
+        {
+          "name": "formatter",
+          "type": "ImPlotFormatter"
+        },
+        {
+          "name": "formatter_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImPlotTicker& ticker,const ImPlotRange& range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "call_args": "(*ticker,range,pixels,vertical,formatter,formatter_data)",
+      "cimguiname": "ImPlot_Locator_SymLog",
+      "defaults": {},
+      "funcname": "Locator_SymLog",
+      "location": "implot_internal:1668",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Locator_SymLog",
+      "ret": "void",
+      "signature": "(ImPlotTicker*,const ImPlotRange,float,bool,ImPlotFormatter,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Locator_Time": [
+    {
+      "args": "(ImPlotTicker* ticker,const ImPlotRange range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "argsT": [
+        {
+          "name": "ticker",
+          "reftoptr": true,
+          "type": "ImPlotTicker*"
+        },
+        {
+          "name": "range",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "pixels",
+          "type": "float"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        },
+        {
+          "name": "formatter",
+          "type": "ImPlotFormatter"
+        },
+        {
+          "name": "formatter_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImPlotTicker& ticker,const ImPlotRange& range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)",
+      "call_args": "(*ticker,range,pixels,vertical,formatter,formatter_data)",
+      "cimguiname": "ImPlot_Locator_Time",
+      "defaults": {},
+      "funcname": "Locator_Time",
+      "location": "implot_internal:1666",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Locator_Time",
+      "ret": "void",
+      "signature": "(ImPlotTicker*,const ImPlotRange,float,bool,ImPlotFormatter,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_MakeTime": [
+    {
+      "args": "(ImPlotTime *pOut,int year,int month,int day,int hour,int min,int sec,int us)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "year",
+          "type": "int"
+        },
+        {
+          "name": "month",
+          "type": "int"
+        },
+        {
+          "name": "day",
+          "type": "int"
+        },
+        {
+          "name": "hour",
+          "type": "int"
+        },
+        {
+          "name": "min",
+          "type": "int"
+        },
+        {
+          "name": "sec",
+          "type": "int"
+        },
+        {
+          "name": "us",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int year,int month=0,int day=1,int hour=0,int min=0,int sec=0,int us=0)",
+      "call_args": "(year,month,day,hour,min,sec,us)",
+      "cimguiname": "ImPlot_MakeTime",
+      "defaults": {
+        "day": "1",
+        "hour": "0",
+        "min": "0",
+        "month": "0",
+        "sec": "0",
+        "us": "0"
+      },
+      "funcname": "MakeTime",
+      "location": "implot_internal:1570",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_MakeTime",
+      "ret": "void",
+      "signature": "(int,int,int,int,int,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_MapInputDefault": [
+    {
+      "args": "(ImPlotInputMap* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImPlotInputMap*"
+        }
+      ],
+      "argsoriginal": "(ImPlotInputMap* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "ImPlot_MapInputDefault",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "MapInputDefault",
+      "location": "implot:1197",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_MapInputDefault",
+      "ret": "void",
+      "signature": "(ImPlotInputMap*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_MapInputReverse": [
+    {
+      "args": "(ImPlotInputMap* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImPlotInputMap*"
+        }
+      ],
+      "argsoriginal": "(ImPlotInputMap* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "ImPlot_MapInputReverse",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "MapInputReverse",
+      "location": "implot:1199",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_MapInputReverse",
+      "ret": "void",
+      "signature": "(ImPlotInputMap*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_MkGmtTime": [
+    {
+      "args": "(ImPlotTime *pOut,struct tm* ptm)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "ptm",
+          "type": "struct tm*"
+        }
+      ],
+      "argsoriginal": "(struct tm* ptm)",
+      "call_args": "(ptm)",
+      "cimguiname": "ImPlot_MkGmtTime",
+      "defaults": {},
+      "funcname": "MkGmtTime",
+      "location": "implot_internal:1556",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_MkGmtTime",
+      "ret": "void",
+      "signature": "(struct tm*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_MkLocTime": [
+    {
+      "args": "(ImPlotTime *pOut,struct tm* ptm)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "ptm",
+          "type": "struct tm*"
+        }
+      ],
+      "argsoriginal": "(struct tm* ptm)",
+      "call_args": "(ptm)",
+      "cimguiname": "ImPlot_MkLocTime",
+      "defaults": {},
+      "funcname": "MkLocTime",
+      "location": "implot_internal:1561",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_MkLocTime",
+      "ret": "void",
+      "signature": "(struct tm*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_NextColormapColor": [
+    {
+      "args": "(ImVec4 *pOut)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        }
+      ],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_NextColormapColor",
+      "defaults": {},
+      "funcname": "NextColormapColor",
+      "location": "implot:1161",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_NextColormapColor",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_NextColormapColorU32": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_NextColormapColorU32",
+      "defaults": {},
+      "funcname": "NextColormapColorU32",
+      "location": "implot_internal:1481",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_NextColormapColorU32",
+      "ret": "ImU32",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_NiceNum": [
+    {
+      "args": "(double x,bool round)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "round",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double x,bool round)",
+      "call_args": "(x,round)",
+      "cimguiname": "ImPlot_NiceNum",
+      "defaults": {},
+      "funcname": "NiceNum",
+      "location": "implot_internal:1493",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_NiceNum",
+      "ret": "double",
+      "signature": "(double,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_OrderOfMagnitude": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_OrderOfMagnitude",
+      "defaults": {},
+      "funcname": "OrderOfMagnitude",
+      "location": "implot_internal:1495",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_OrderOfMagnitude",
+      "ret": "int",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_OrderToPrecision": [
+    {
+      "args": "(int order)",
+      "argsT": [
+        {
+          "name": "order",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int order)",
+      "call_args": "(order)",
+      "cimguiname": "ImPlot_OrderToPrecision",
+      "defaults": {},
+      "funcname": "OrderToPrecision",
+      "location": "implot_internal:1497",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_OrderToPrecision",
+      "ret": "int",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PixelsToPlot": [
+    {
+      "args": "(ImPlotPoint *pOut,const ImVec2 pix,ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "pix",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(const ImVec2& pix,ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(pix,x_axis,y_axis)",
+      "cimguiname": "ImPlot_PixelsToPlot",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "PixelsToPlot",
+      "location": "implot:955",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_PixelsToPlot_Vec2",
+      "ret": "void",
+      "signature": "(const ImVec2,ImAxis,ImAxis)",
+      "stname": ""
+    },
+    {
+      "args": "(ImPlotPoint *pOut,float x,float y,ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotPoint*"
+        },
+        {
+          "name": "x",
+          "type": "float"
+        },
+        {
+          "name": "y",
+          "type": "float"
+        },
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(float x,float y,ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(x,y,x_axis,y_axis)",
+      "cimguiname": "ImPlot_PixelsToPlot",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "PixelsToPlot",
+      "location": "implot:956",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_PixelsToPlot_Float",
+      "ret": "void",
+      "signature": "(float,float,ImAxis,ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotBarGroups": [
+    {
+      "args": "(const char* const label_ids[],const float* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const float* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_FloatPtr",
+      "ret": "void",
+      "signature": "(const char* const[],const float*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const double* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const double* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_doublePtr",
+      "ret": "void",
+      "signature": "(const char* const[],const double*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS8* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS8* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_S8Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS8*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU8* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU8* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_U8Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU8*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS16* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS16* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_S16Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS16*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU16* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU16* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_U16Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU16*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS32* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS32* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_S32Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS32*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU32* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU32* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_U32Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU32*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS64* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS64* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_S64Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS64*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU64* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "item_count",
+          "type": "int"
+        },
+        {
+          "name": "group_count",
+          "type": "int"
+        },
+        {
+          "name": "group_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarGroupsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU64* values,int item_count,int group_count,double group_size=0.67,double shift=0,ImPlotBarGroupsFlags flags=0)",
+      "call_args": "(label_ids,values,item_count,group_count,group_size,shift,flags)",
+      "cimguiname": "ImPlot_PlotBarGroups",
+      "defaults": {
+        "flags": "0",
+        "group_size": "0.67",
+        "shift": "0"
+      },
+      "funcname": "PlotBarGroups",
+      "location": "implot:874",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarGroups_U64Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU64*,int,int,double,double,ImPlotBarGroupsFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotBars": [
+    {
+      "args": "(const char* label_id,const float* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_FloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_doublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "shift",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,double bar_size=0.67,double shift=0,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,bar_size,shift,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "bar_size": "0.67",
+        "flags": "0",
+        "offset": "0",
+        "shift": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:869",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,double,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_FloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_doublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_S64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double bar_size,ImPlotBarsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,bar_size,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotBars",
+      "location": "implot:870",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBars_U64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,double,ImPlotBarsFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotBarsG": [
+    {
+      "args": "(const char* label_id,ImPlotGetter getter,void* data,int count,double bar_size,ImPlotBarsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bar_size",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotBarsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotGetter getter,void* data,int count,double bar_size,ImPlotBarsFlags flags=0)",
+      "call_args": "(label_id,getter,data,count,bar_size,flags)",
+      "cimguiname": "ImPlot_PlotBarsG",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotBarsG",
+      "location": "implot:871",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotBarsG",
+      "ret": "void",
+      "signature": "(const char*,ImPlotGetter,void*,int,double,ImPlotBarsFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotDigital": [
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_FloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_doublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_S8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_U8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_S16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_U16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_S32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_U32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_S64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotDigitalFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotDigital",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotDigital",
+      "location": "implot:902",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigital_U64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,ImPlotDigitalFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotDigitalG": [
+    {
+      "args": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotDigitalFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDigitalFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotDigitalFlags flags=0)",
+      "call_args": "(label_id,getter,data,count,flags)",
+      "cimguiname": "ImPlot_PlotDigitalG",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotDigitalG",
+      "location": "implot:903",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDigitalG",
+      "ret": "void",
+      "signature": "(const char*,ImPlotGetter,void*,int,ImPlotDigitalFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotDummy": [
+    {
+      "args": "(const char* label_id,ImPlotDummyFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotDummyFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotDummyFlags flags=0)",
+      "call_args": "(label_id,flags)",
+      "cimguiname": "ImPlot_PlotDummy",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotDummy",
+      "location": "implot:912",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotDummy",
+      "ret": "void",
+      "signature": "(const char*,ImPlotDummyFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotErrorBars": [
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,const float* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "err",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,const float* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,const float*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,const double* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "err",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,const double* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,const double*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,const ImS8* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "err",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,const ImS8* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,const ImS8*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,const ImU8* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "err",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,const ImU8* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,const ImU8*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,const ImS16* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "err",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,const ImS16* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,const ImS16*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,const ImU16* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "err",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,const ImU16* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,const ImU16*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,const ImS32* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "err",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,const ImS32* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,const ImS32*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,const ImU32* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "err",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,const ImU32* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,const ImU32*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,const ImS64* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "err",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,const ImS64* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,const ImS64*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,const ImU64* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "err",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,const ImU64* err,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,err,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:877",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,const ImU64*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,const float* neg,const float* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "neg",
+          "type": "const float*"
+        },
+        {
+          "name": "pos",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,const float* neg,const float* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,const float*,const float*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,const double* neg,const double* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "neg",
+          "type": "const double*"
+        },
+        {
+          "name": "pos",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,const double* neg,const double* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,const double*,const double*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,const ImS8* neg,const ImS8* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,const ImS8* neg,const ImS8* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,const ImS8*,const ImS8*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,const ImU8* neg,const ImU8* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,const ImU8* neg,const ImU8* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,const ImU8*,const ImU8*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,const ImS16* neg,const ImS16* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,const ImS16* neg,const ImS16* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,const ImS16*,const ImS16*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,const ImU16* neg,const ImU16* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,const ImU16* neg,const ImU16* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,const ImU16*,const ImU16*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,const ImS32* neg,const ImS32* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,const ImS32* neg,const ImS32* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,const ImS32*,const ImS32*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,const ImU32* neg,const ImU32* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,const ImU32* neg,const ImU32* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,const ImU32*,const ImU32*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,const ImS64* neg,const ImS64* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,const ImS64* neg,const ImS64* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,const ImS64*,const ImS64*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,const ImU64* neg,const ImU64* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "neg",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "pos",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotErrorBarsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,const ImU64* neg,const ImU64* pos,int count,ImPlotErrorBarsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,neg,pos,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotErrorBars",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotErrorBars",
+      "location": "implot:878",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,const ImU64*,const ImU64*,int,ImPlotErrorBarsFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotHeatmap": [
+    {
+      "args": "(const char* label_id,const float* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_FloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_doublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_S8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_U8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_S16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_U16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_S32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_U32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_S64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,ImPlotHeatmapFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "rows",
+          "type": "int"
+        },
+        {
+          "name": "cols",
+          "type": "int"
+        },
+        {
+          "name": "scale_min",
+          "type": "double"
+        },
+        {
+          "name": "scale_max",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHeatmapFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int rows,int cols,double scale_min=0,double scale_max=0,const char* label_fmt=\"%.1f\",const ImPlotPoint& bounds_min=ImPlotPoint(0,0),const ImPlotPoint& bounds_max=ImPlotPoint(1,1),ImPlotHeatmapFlags flags=0)",
+      "call_args": "(label_id,values,rows,cols,scale_min,scale_max,label_fmt,bounds_min,bounds_max,flags)",
+      "cimguiname": "ImPlot_PlotHeatmap",
+      "defaults": {
+        "bounds_max": "ImPlotPoint(1,1)",
+        "bounds_min": "ImPlotPoint(0,0)",
+        "flags": "0",
+        "label_fmt": "\"%.1f\"",
+        "scale_max": "0",
+        "scale_min": "0"
+      },
+      "funcname": "PlotHeatmap",
+      "location": "implot:891",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHeatmap_U64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,int,double,double,const char*,const ImPlotPoint,const ImPlotPoint,ImPlotHeatmapFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotHistogram": [
+    {
+      "args": "(const char* label_id,const float* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_FloatPtr",
+      "ret": "double",
+      "signature": "(const char*,const float*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_doublePtr",
+      "ret": "double",
+      "signature": "(const char*,const double*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_S8Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS8*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_U8Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU8*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_S16Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS16*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_U16Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU16*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_S32Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS32*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_U32Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU32*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_S64Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS64*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,int bins,double bar_scale,ImPlotRange range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "bins",
+          "type": "int"
+        },
+        {
+          "name": "bar_scale",
+          "type": "double"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRange"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,int bins=ImPlotBin_Sturges,double bar_scale=1.0,ImPlotRange range=ImPlotRange(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,values,count,bins,bar_scale,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram",
+      "defaults": {
+        "bar_scale": "1.0",
+        "bins": "ImPlotBin_Sturges",
+        "flags": "0",
+        "range": "ImPlotRange()"
+      },
+      "funcname": "PlotHistogram",
+      "location": "implot:895",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram_U64Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU64*,int,int,double,ImPlotRange,ImPlotHistogramFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotHistogram2D": [
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_FloatPtr",
+      "ret": "double",
+      "signature": "(const char*,const float*,const float*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_doublePtr",
+      "ret": "double",
+      "signature": "(const char*,const double*,const double*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_S8Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_U8Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_S16Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_U16Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_S32Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_U32Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_S64Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,int x_bins,int y_bins,ImPlotRect range,ImPlotHistogramFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x_bins",
+          "type": "int"
+        },
+        {
+          "name": "y_bins",
+          "type": "int"
+        },
+        {
+          "name": "range",
+          "type": "ImPlotRect"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotHistogramFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,int x_bins=ImPlotBin_Sturges,int y_bins=ImPlotBin_Sturges,ImPlotRect range=ImPlotRect(),ImPlotHistogramFlags flags=0)",
+      "call_args": "(label_id,xs,ys,count,x_bins,y_bins,range,flags)",
+      "cimguiname": "ImPlot_PlotHistogram2D",
+      "defaults": {
+        "flags": "0",
+        "range": "ImPlotRect()",
+        "x_bins": "ImPlotBin_Sturges",
+        "y_bins": "ImPlotBin_Sturges"
+      },
+      "funcname": "PlotHistogram2D",
+      "location": "implot:899",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotHistogram2D_U64Ptr",
+      "ret": "double",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,int,int,ImPlotRect,ImPlotHistogramFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotImage": [
+    {
+      "args": "(const char* label_id,ImTextureID user_texture_id,const ImPlotPoint bounds_min,const ImPlotPoint bounds_max,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,ImPlotImageFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "user_texture_id",
+          "type": "ImTextureID"
+        },
+        {
+          "name": "bounds_min",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "bounds_max",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "uv0",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "uv1",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "tint_col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotImageFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImTextureID user_texture_id,const ImPlotPoint& bounds_min,const ImPlotPoint& bounds_max,const ImVec2& uv0=ImVec2(0,0),const ImVec2& uv1=ImVec2(1,1),const ImVec4& tint_col=ImVec4(1,1,1,1),ImPlotImageFlags flags=0)",
+      "call_args": "(label_id,user_texture_id,bounds_min,bounds_max,uv0,uv1,tint_col,flags)",
+      "cimguiname": "ImPlot_PlotImage",
+      "defaults": {
+        "flags": "0",
+        "tint_col": "ImVec4(1,1,1,1)",
+        "uv0": "ImVec2(0,0)",
+        "uv1": "ImVec2(1,1)"
+      },
+      "funcname": "PlotImage",
+      "location": "implot:906",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotImage",
+      "ret": "void",
+      "signature": "(const char*,ImTextureID,const ImPlotPoint,const ImPlotPoint,const ImVec2,const ImVec2,const ImVec4,ImPlotImageFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotInfLines": [
+    {
+      "args": "(const char* label_id,const float* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_FloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_doublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_S8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_U8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_S16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_U16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_S32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_U32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_S64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotInfLinesFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,ImPlotInfLinesFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotInfLines",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotInfLines",
+      "location": "implot:885",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotInfLines_U64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,ImPlotInfLinesFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotLine": [
+    {
+      "args": "(const char* label_id,const float* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_FloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_doublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,double xscale=1,double xstart=0,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:848",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,double,double,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_FloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_doublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_S64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotLineFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotLineFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotLine",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotLine",
+      "location": "implot:849",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLine_U64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,ImPlotLineFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotLineG": [
+    {
+      "args": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotLineFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLineFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotLineFlags flags=0)",
+      "call_args": "(label_id,getter,data,count,flags)",
+      "cimguiname": "ImPlot_PlotLineG",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotLineG",
+      "location": "implot:850",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotLineG",
+      "ret": "void",
+      "signature": "(const char*,ImPlotGetter,void*,int,ImPlotLineFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotPieChart": [
+    {
+      "args": "(const char* const label_ids[],const float* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const float* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_FloatPtr",
+      "ret": "void",
+      "signature": "(const char* const[],const float*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const double* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const double* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_doublePtr",
+      "ret": "void",
+      "signature": "(const char* const[],const double*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS8* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS8* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_S8Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS8*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU8* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU8* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_U8Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU8*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS16* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS16* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_S16Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS16*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU16* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU16* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_U16Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU16*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS32* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS32* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_S32Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS32*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU32* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU32* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_U32Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU32*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImS64* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImS64* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_S64Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImS64*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* const label_ids[],const ImU64* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)",
+      "argsT": [
+        {
+          "name": "label_ids",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "radius",
+          "type": "double"
+        },
+        {
+          "name": "label_fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "angle0",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotPieChartFlags"
+        }
+      ],
+      "argsoriginal": "(const char* const label_ids[],const ImU64* values,int count,double x,double y,double radius,const char* label_fmt=\"%.1f\",double angle0=90,ImPlotPieChartFlags flags=0)",
+      "call_args": "(label_ids,values,count,x,y,radius,label_fmt,angle0,flags)",
+      "cimguiname": "ImPlot_PlotPieChart",
+      "defaults": {
+        "angle0": "90",
+        "flags": "0",
+        "label_fmt": "\"%.1f\""
+      },
+      "funcname": "PlotPieChart",
+      "location": "implot:888",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotPieChart_U64Ptr",
+      "ret": "void",
+      "signature": "(const char* const[],const ImU64*,int,double,double,double,const char*,double,ImPlotPieChartFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotScatter": [
+    {
+      "args": "(const char* label_id,const float* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_FloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_doublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,double xscale=1,double xstart=0,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:853",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,double,double,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_FloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_doublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_S64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotScatterFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotScatterFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotScatter",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotScatter",
+      "location": "implot:854",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatter_U64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,ImPlotScatterFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotScatterG": [
+    {
+      "args": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotScatterFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotScatterFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotScatterFlags flags=0)",
+      "call_args": "(label_id,getter,data,count,flags)",
+      "cimguiname": "ImPlot_PlotScatterG",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotScatterG",
+      "location": "implot:855",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotScatterG",
+      "ret": "void",
+      "signature": "(const char*,ImPlotGetter,void*,int,ImPlotScatterFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotShaded": [
+    {
+      "args": "(const char* label_id,const float* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_FloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_doublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,double yref=0,double xscale=1,double xstart=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,yref,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)",
+        "xscale": "1",
+        "xstart": "0",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:863",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,double,double,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_FloatPtrFloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_doublePtrdoublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S8PtrS8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U8PtrU8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S16PtrS16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U16PtrU16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S32PtrS32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U32PtrU32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S64PtrS64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "yref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double yref=0,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,yref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)",
+        "yref": "0"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:864",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U64PtrU64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,double,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys1,const float* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys1",
+          "type": "const float*"
+        },
+        {
+          "name": "ys2",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys1,const float* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,const float*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys1,const double* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys1",
+          "type": "const double*"
+        },
+        {
+          "name": "ys2",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys1,const double* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,const double*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys1,const ImS8* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys1,const ImS8* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S8PtrS8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,const ImS8*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys1,const ImU8* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys1,const ImU8* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U8PtrU8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,const ImU8*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys1,const ImS16* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys1,const ImS16* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S16PtrS16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,const ImS16*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys1,const ImU16* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys1,const ImU16* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U16PtrU16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,const ImU16*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys1,const ImS32* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys1,const ImS32* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S32PtrS32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,const ImS32*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys1,const ImU32* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys1,const ImU32* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U32PtrU32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,const ImU32*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys1,const ImS64* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys1,const ImS64* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_S64PtrS64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,const ImS64*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys1,const ImU64* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys1",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys2",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys1,const ImU64* ys2,int count,ImPlotShadedFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys1,ys2,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotShaded",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotShaded",
+      "location": "implot:865",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShaded_U64PtrU64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,const ImU64*,int,ImPlotShadedFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotShadedG": [
+    {
+      "args": "(const char* label_id,ImPlotGetter getter1,void* data1,ImPlotGetter getter2,void* data2,int count,ImPlotShadedFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter1",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data1",
+          "type": "void*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter2",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data2",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotShadedFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotGetter getter1,void* data1,ImPlotGetter getter2,void* data2,int count,ImPlotShadedFlags flags=0)",
+      "call_args": "(label_id,getter1,data1,getter2,data2,count,flags)",
+      "cimguiname": "ImPlot_PlotShadedG",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotShadedG",
+      "location": "implot:866",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotShadedG",
+      "ret": "void",
+      "signature": "(const char*,ImPlotGetter,void*,ImPlotGetter,void*,int,ImPlotShadedFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotStairs": [
+    {
+      "args": "(const char* label_id,const float* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_FloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_doublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "xscale",
+          "type": "double"
+        },
+        {
+          "name": "xstart",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,double xscale=1,double xstart=0,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,xscale,xstart,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)",
+        "xscale": "1",
+        "xstart": "0"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:858",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,double,double,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_FloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_doublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_S64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotStairsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotStairsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStairs",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotStairs",
+      "location": "implot:859",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairs_U64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,ImPlotStairsFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotStairsG": [
+    {
+      "args": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotStairsFlags flags)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "custom_type": "ImPlotPoint_getter",
+          "name": "getter",
+          "type": "ImPlotGetter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStairsFlags"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotGetter getter,void* data,int count,ImPlotStairsFlags flags=0)",
+      "call_args": "(label_id,getter,data,count,flags)",
+      "cimguiname": "ImPlot_PlotStairsG",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "PlotStairsG",
+      "location": "implot:860",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStairsG",
+      "ret": "void",
+      "signature": "(const char*,ImPlotGetter,void*,int,ImPlotStairsFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotStems": [
+    {
+      "args": "(const char* label_id,const float* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_FloatPtrInt",
+      "ret": "void",
+      "signature": "(const char*,const float*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_doublePtrInt",
+      "ret": "void",
+      "signature": "(const char*,const double*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U8PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U16PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U32PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "values",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "scale",
+          "type": "double"
+        },
+        {
+          "name": "start",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* values,int count,double ref=0,double scale=1,double start=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,values,count,ref,scale,start,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "scale": "1",
+        "start": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:881",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U64PtrInt",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,int,double,double,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const float* xs,const float* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const float*"
+        },
+        {
+          "name": "ys",
+          "type": "const float*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const float* xs,const float* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(float))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(float)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_FloatPtrFloatPtr",
+      "ret": "void",
+      "signature": "(const char*,const float*,const float*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const double* xs,const double* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const double*"
+        },
+        {
+          "name": "ys",
+          "type": "const double*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const double* xs,const double* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(double))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(double)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_doublePtrdoublePtr",
+      "ret": "void",
+      "signature": "(const char*,const double*,const double*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS8))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImS8)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S8PtrS8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS8*,const ImS8*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU8*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU8))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImU8)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U8PtrU8Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU8*,const ImU8*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS16))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImS16)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S16PtrS16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS16*,const ImS16*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU16*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU16))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImU16)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U16PtrU16Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU16*,const ImU16*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS32))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImS32)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S32PtrS32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS32*,const ImS32*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU32))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImU32)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U32PtrU32Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU32*,const ImU32*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImS64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImS64))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImS64)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_S64PtrS64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImS64*,const ImS64*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "xs",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "ys",
+          "type": "const ImU64*"
+        },
+        {
+          "name": "count",
+          "type": "int"
+        },
+        {
+          "name": "ref",
+          "type": "double"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotStemsFlags"
+        },
+        {
+          "name": "offset",
+          "type": "int"
+        },
+        {
+          "name": "stride",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double ref=0,ImPlotStemsFlags flags=0,int offset=0,int stride=sizeof(ImU64))",
+      "call_args": "(label_id,xs,ys,count,ref,flags,offset,stride)",
+      "cimguiname": "ImPlot_PlotStems",
+      "defaults": {
+        "flags": "0",
+        "offset": "0",
+        "ref": "0",
+        "stride": "sizeof(ImU64)"
+      },
+      "funcname": "PlotStems",
+      "location": "implot:882",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotStems_U64PtrU64Ptr",
+      "ret": "void",
+      "signature": "(const char*,const ImU64*,const ImU64*,int,double,ImPlotStemsFlags,int,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotText": [
+    {
+      "args": "(const char* text,double x,double y,const ImVec2 pix_offset,ImPlotTextFlags flags)",
+      "argsT": [
+        {
+          "name": "text",
+          "type": "const char*"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "pix_offset",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotTextFlags"
+        }
+      ],
+      "argsoriginal": "(const char* text,double x,double y,const ImVec2& pix_offset=ImVec2(0,0),ImPlotTextFlags flags=0)",
+      "call_args": "(text,x,y,pix_offset,flags)",
+      "cimguiname": "ImPlot_PlotText",
+      "defaults": {
+        "flags": "0",
+        "pix_offset": "ImVec2(0,0)"
+      },
+      "funcname": "PlotText",
+      "location": "implot:909",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PlotText",
+      "ret": "void",
+      "signature": "(const char*,double,double,const ImVec2,ImPlotTextFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PlotToPixels": [
+    {
+      "args": "(ImVec2 *pOut,const ImPlotPoint plt,ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "plt",
+          "type": "const ImPlotPoint"
+        },
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(const ImPlotPoint& plt,ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(plt,x_axis,y_axis)",
+      "cimguiname": "ImPlot_PlotToPixels",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "PlotToPixels",
+      "location": "implot:959",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_PlotToPixels_PlotPoInt",
+      "ret": "void",
+      "signature": "(const ImPlotPoint,ImAxis,ImAxis)",
+      "stname": ""
+    },
+    {
+      "args": "(ImVec2 *pOut,double x,double y,ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec2*"
+        },
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(double x,double y,ImAxis x_axis=-1,ImAxis y_axis=-1)",
+      "call_args": "(x,y,x_axis,y_axis)",
+      "cimguiname": "ImPlot_PlotToPixels",
+      "defaults": {
+        "x_axis": "-1",
+        "y_axis": "-1"
+      },
+      "funcname": "PlotToPixels",
+      "location": "implot:960",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_PlotToPixels_double",
+      "ret": "void",
+      "signature": "(double,double,ImAxis,ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PopColormap": [
+    {
+      "args": "(int count)",
+      "argsT": [
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int count=1)",
+      "call_args": "(count)",
+      "cimguiname": "ImPlot_PopColormap",
+      "defaults": {
+        "count": "1"
+      },
+      "funcname": "PopColormap",
+      "location": "implot:1157",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PopColormap",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PopPlotClipRect": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_PopPlotClipRect",
+      "defaults": {},
+      "funcname": "PopPlotClipRect",
+      "location": "implot:1215",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PopPlotClipRect",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PopStyleColor": [
+    {
+      "args": "(int count)",
+      "argsT": [
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int count=1)",
+      "call_args": "(count)",
+      "cimguiname": "ImPlot_PopStyleColor",
+      "defaults": {
+        "count": "1"
+      },
+      "funcname": "PopStyleColor",
+      "location": "implot:1090",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PopStyleColor",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PopStyleVar": [
+    {
+      "args": "(int count)",
+      "argsT": [
+        {
+          "name": "count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int count=1)",
+      "call_args": "(count)",
+      "cimguiname": "ImPlot_PopStyleVar",
+      "defaults": {
+        "count": "1"
+      },
+      "funcname": "PopStyleVar",
+      "location": "implot:1099",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PopStyleVar",
+      "ret": "void",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_Precision": [
+    {
+      "args": "(double val)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(double val)",
+      "call_args": "(val)",
+      "cimguiname": "ImPlot_Precision",
+      "defaults": {},
+      "funcname": "Precision",
+      "location": "implot_internal:1499",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_Precision",
+      "ret": "int",
+      "signature": "(double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PushColormap": [
+    {
+      "args": "(ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(ImPlotColormap cmap)",
+      "call_args": "(cmap)",
+      "cimguiname": "ImPlot_PushColormap",
+      "defaults": {},
+      "funcname": "PushColormap",
+      "location": "implot:1153",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushColormap_PlotColormap",
+      "ret": "void",
+      "signature": "(ImPlotColormap)",
+      "stname": ""
+    },
+    {
+      "args": "(const char* name)",
+      "argsT": [
+        {
+          "name": "name",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* name)",
+      "call_args": "(name)",
+      "cimguiname": "ImPlot_PushColormap",
+      "defaults": {},
+      "funcname": "PushColormap",
+      "location": "implot:1155",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushColormap_Str",
+      "ret": "void",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PushPlotClipRect": [
+    {
+      "args": "(float expand)",
+      "argsT": [
+        {
+          "name": "expand",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(float expand=0)",
+      "call_args": "(expand)",
+      "cimguiname": "ImPlot_PushPlotClipRect",
+      "defaults": {
+        "expand": "0"
+      },
+      "funcname": "PushPlotClipRect",
+      "location": "implot:1213",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushPlotClipRect",
+      "ret": "void",
+      "signature": "(float)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PushStyleColor": [
+    {
+      "args": "(ImPlotCol idx,ImU32 col)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        },
+        {
+          "name": "col",
+          "type": "ImU32"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx,ImU32 col)",
+      "call_args": "(idx,col)",
+      "cimguiname": "ImPlot_PushStyleColor",
+      "defaults": {},
+      "funcname": "PushStyleColor",
+      "location": "implot:1087",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushStyleColor_U32",
+      "ret": "void",
+      "signature": "(ImPlotCol,ImU32)",
+      "stname": ""
+    },
+    {
+      "args": "(ImPlotCol idx,const ImVec4 col)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotCol"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(ImPlotCol idx,const ImVec4& col)",
+      "call_args": "(idx,col)",
+      "cimguiname": "ImPlot_PushStyleColor",
+      "defaults": {},
+      "funcname": "PushStyleColor",
+      "location": "implot:1088",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushStyleColor_Vec4",
+      "ret": "void",
+      "signature": "(ImPlotCol,const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_PushStyleVar": [
+    {
+      "args": "(ImPlotStyleVar idx,float val)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotStyleVar"
+        },
+        {
+          "name": "val",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyleVar idx,float val)",
+      "call_args": "(idx,val)",
+      "cimguiname": "ImPlot_PushStyleVar",
+      "defaults": {},
+      "funcname": "PushStyleVar",
+      "location": "implot:1093",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushStyleVar_Float",
+      "ret": "void",
+      "signature": "(ImPlotStyleVar,float)",
+      "stname": ""
+    },
+    {
+      "args": "(ImPlotStyleVar idx,int val)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotStyleVar"
+        },
+        {
+          "name": "val",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyleVar idx,int val)",
+      "call_args": "(idx,val)",
+      "cimguiname": "ImPlot_PushStyleVar",
+      "defaults": {},
+      "funcname": "PushStyleVar",
+      "location": "implot:1095",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushStyleVar_Int",
+      "ret": "void",
+      "signature": "(ImPlotStyleVar,int)",
+      "stname": ""
+    },
+    {
+      "args": "(ImPlotStyleVar idx,const ImVec2 val)",
+      "argsT": [
+        {
+          "name": "idx",
+          "type": "ImPlotStyleVar"
+        },
+        {
+          "name": "val",
+          "type": "const ImVec2"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyleVar idx,const ImVec2& val)",
+      "call_args": "(idx,val)",
+      "cimguiname": "ImPlot_PushStyleVar",
+      "defaults": {},
+      "funcname": "PushStyleVar",
+      "location": "implot:1097",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_PushStyleVar_Vec2",
+      "ret": "void",
+      "signature": "(ImPlotStyleVar,const ImVec2)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_RangesOverlap": [
+    {
+      "args": "(const ImPlotRange r1,const ImPlotRange r2)",
+      "argsT": [
+        {
+          "name": "r1",
+          "type": "const ImPlotRange"
+        },
+        {
+          "name": "r2",
+          "type": "const ImPlotRange"
+        }
+      ],
+      "argsoriginal": "(const ImPlotRange& r1,const ImPlotRange& r2)",
+      "call_args": "(r1,r2)",
+      "cimguiname": "ImPlot_RangesOverlap",
+      "defaults": {},
+      "funcname": "RangesOverlap",
+      "location": "implot_internal:1408",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_RangesOverlap",
+      "ret": "bool",
+      "signature": "(const ImPlotRange,const ImPlotRange)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_RegisterOrGetItem": [
+    {
+      "args": "(const char* label_id,ImPlotItemFlags flags,bool* just_created)",
+      "argsT": [
+        {
+          "name": "label_id",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotItemFlags"
+        },
+        {
+          "name": "just_created",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(const char* label_id,ImPlotItemFlags flags,bool* just_created=((void*)0))",
+      "call_args": "(label_id,flags,just_created)",
+      "cimguiname": "ImPlot_RegisterOrGetItem",
+      "defaults": {
+        "just_created": "NULL"
+      },
+      "funcname": "RegisterOrGetItem",
+      "location": "implot_internal:1333",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_RegisterOrGetItem",
+      "ret": "ImPlotItem*",
+      "signature": "(const char*,ImPlotItemFlags,bool*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_RenderColorBar": [
+    {
+      "args": "(const ImU32* colors,int size,ImDrawList* DrawList,const ImRect bounds,bool vert,bool reversed,bool continuous)",
+      "argsT": [
+        {
+          "name": "colors",
+          "type": "const ImU32*"
+        },
+        {
+          "name": "size",
+          "type": "int"
+        },
+        {
+          "name": "DrawList",
+          "reftoptr": true,
+          "type": "ImDrawList*"
+        },
+        {
+          "name": "bounds",
+          "type": "const ImRect"
+        },
+        {
+          "name": "vert",
+          "type": "bool"
+        },
+        {
+          "name": "reversed",
+          "type": "bool"
+        },
+        {
+          "name": "continuous",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const ImU32* colors,int size,ImDrawList& DrawList,const ImRect& bounds,bool vert,bool reversed,bool continuous)",
+      "call_args": "(colors,size,*DrawList,bounds,vert,reversed,continuous)",
+      "cimguiname": "ImPlot_RenderColorBar",
+      "defaults": {},
+      "funcname": "RenderColorBar",
+      "location": "implot_internal:1486",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_RenderColorBar",
+      "ret": "void",
+      "signature": "(const ImU32*,int,ImDrawList*,const ImRect,bool,bool,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ResetCtxForNextAlignedPlots": [
+    {
+      "args": "(ImPlotContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImPlotContext*"
+        }
+      ],
+      "argsoriginal": "(ImPlotContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_ResetCtxForNextAlignedPlots",
+      "defaults": {},
+      "funcname": "ResetCtxForNextAlignedPlots",
+      "location": "implot_internal:1271",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ResetCtxForNextAlignedPlots",
+      "ret": "void",
+      "signature": "(ImPlotContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ResetCtxForNextPlot": [
+    {
+      "args": "(ImPlotContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImPlotContext*"
+        }
+      ],
+      "argsoriginal": "(ImPlotContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_ResetCtxForNextPlot",
+      "defaults": {},
+      "funcname": "ResetCtxForNextPlot",
+      "location": "implot_internal:1269",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ResetCtxForNextPlot",
+      "ret": "void",
+      "signature": "(ImPlotContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ResetCtxForNextSubplot": [
+    {
+      "args": "(ImPlotContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImPlotContext*"
+        }
+      ],
+      "argsoriginal": "(ImPlotContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_ResetCtxForNextSubplot",
+      "defaults": {},
+      "funcname": "ResetCtxForNextSubplot",
+      "location": "implot_internal:1273",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ResetCtxForNextSubplot",
+      "ret": "void",
+      "signature": "(ImPlotContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_RoundTime": [
+    {
+      "args": "(ImPlotTime *pOut,const ImPlotTime t,ImPlotTimeUnit unit)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "t",
+          "type": "const ImPlotTime"
+        },
+        {
+          "name": "unit",
+          "type": "ImPlotTimeUnit"
+        }
+      ],
+      "argsoriginal": "(const ImPlotTime& t,ImPlotTimeUnit unit)",
+      "call_args": "(t,unit)",
+      "cimguiname": "ImPlot_RoundTime",
+      "defaults": {},
+      "funcname": "RoundTime",
+      "location": "implot_internal:1581",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_RoundTime",
+      "ret": "void",
+      "signature": "(const ImPlotTime,ImPlotTimeUnit)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_RoundTo": [
+    {
+      "args": "(double val,int prec)",
+      "argsT": [
+        {
+          "name": "val",
+          "type": "double"
+        },
+        {
+          "name": "prec",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(double val,int prec)",
+      "call_args": "(val,prec)",
+      "cimguiname": "ImPlot_RoundTo",
+      "defaults": {},
+      "funcname": "RoundTo",
+      "location": "implot_internal:1501",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_RoundTo",
+      "ret": "double",
+      "signature": "(double,int)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SampleColormap": [
+    {
+      "args": "(ImVec4 *pOut,float t,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "pOut",
+          "type": "ImVec4*"
+        },
+        {
+          "name": "t",
+          "type": "float"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(float t,ImPlotColormap cmap=-1)",
+      "call_args": "(t,cmap)",
+      "cimguiname": "ImPlot_SampleColormap",
+      "defaults": {
+        "cmap": "-1"
+      },
+      "funcname": "SampleColormap",
+      "location": "implot:1171",
+      "namespace": "ImPlot",
+      "nonUDT": 1,
+      "ov_cimguiname": "ImPlot_SampleColormap",
+      "ret": "void",
+      "signature": "(float,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SampleColormapU32": [
+    {
+      "args": "(float t,ImPlotColormap cmap)",
+      "argsT": [
+        {
+          "name": "t",
+          "type": "float"
+        },
+        {
+          "name": "cmap",
+          "type": "ImPlotColormap"
+        }
+      ],
+      "argsoriginal": "(float t,ImPlotColormap cmap)",
+      "call_args": "(t,cmap)",
+      "cimguiname": "ImPlot_SampleColormapU32",
+      "defaults": {},
+      "funcname": "SampleColormapU32",
+      "location": "implot_internal:1483",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SampleColormapU32",
+      "ret": "ImU32",
+      "signature": "(float,ImPlotColormap)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetAxes": [
+    {
+      "args": "(ImAxis x_axis,ImAxis y_axis)",
+      "argsT": [
+        {
+          "name": "x_axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "y_axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis x_axis,ImAxis y_axis)",
+      "call_args": "(x_axis,y_axis)",
+      "cimguiname": "ImPlot_SetAxes",
+      "defaults": {},
+      "funcname": "SetAxes",
+      "location": "implot:952",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetAxes",
+      "ret": "void",
+      "signature": "(ImAxis,ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetAxis": [
+    {
+      "args": "(ImAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "ImPlot_SetAxis",
+      "defaults": {},
+      "funcname": "SetAxis",
+      "location": "implot:951",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetAxis",
+      "ret": "void",
+      "signature": "(ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetCurrentContext": [
+    {
+      "args": "(ImPlotContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImPlotContext*"
+        }
+      ],
+      "argsoriginal": "(ImPlotContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_SetCurrentContext",
+      "defaults": {},
+      "funcname": "SetCurrentContext",
+      "location": "implot:598",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetCurrentContext",
+      "ret": "void",
+      "signature": "(ImPlotContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetImGuiContext": [
+    {
+      "args": "(ImGuiContext* ctx)",
+      "argsT": [
+        {
+          "name": "ctx",
+          "type": "ImGuiContext*"
+        }
+      ],
+      "argsoriginal": "(ImGuiContext* ctx)",
+      "call_args": "(ctx)",
+      "cimguiname": "ImPlot_SetImGuiContext",
+      "defaults": {},
+      "funcname": "SetImGuiContext",
+      "location": "implot:604",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetImGuiContext",
+      "ret": "void",
+      "signature": "(ImGuiContext*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextAxesLimits": [
+    {
+      "args": "(double x_min,double x_max,double y_min,double y_max,ImPlotCond cond)",
+      "argsT": [
+        {
+          "name": "x_min",
+          "type": "double"
+        },
+        {
+          "name": "x_max",
+          "type": "double"
+        },
+        {
+          "name": "y_min",
+          "type": "double"
+        },
+        {
+          "name": "y_max",
+          "type": "double"
+        },
+        {
+          "name": "cond",
+          "type": "ImPlotCond"
+        }
+      ],
+      "argsoriginal": "(double x_min,double x_max,double y_min,double y_max,ImPlotCond cond=ImPlotCond_Once)",
+      "call_args": "(x_min,x_max,y_min,y_max,cond)",
+      "cimguiname": "ImPlot_SetNextAxesLimits",
+      "defaults": {
+        "cond": "ImPlotCond_Once"
+      },
+      "funcname": "SetNextAxesLimits",
+      "location": "implot:791",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextAxesLimits",
+      "ret": "void",
+      "signature": "(double,double,double,double,ImPlotCond)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextAxesToFit": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_SetNextAxesToFit",
+      "defaults": {},
+      "funcname": "SetNextAxesToFit",
+      "location": "implot:793",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextAxesToFit",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextAxisLimits": [
+    {
+      "args": "(ImAxis axis,double v_min,double v_max,ImPlotCond cond)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "v_min",
+          "type": "double"
+        },
+        {
+          "name": "v_max",
+          "type": "double"
+        },
+        {
+          "name": "cond",
+          "type": "ImPlotCond"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double v_min,double v_max,ImPlotCond cond=ImPlotCond_Once)",
+      "call_args": "(axis,v_min,v_max,cond)",
+      "cimguiname": "ImPlot_SetNextAxisLimits",
+      "defaults": {
+        "cond": "ImPlotCond_Once"
+      },
+      "funcname": "SetNextAxisLimits",
+      "location": "implot:784",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextAxisLimits",
+      "ret": "void",
+      "signature": "(ImAxis,double,double,ImPlotCond)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextAxisLinks": [
+    {
+      "args": "(ImAxis axis,double* link_min,double* link_max)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "link_min",
+          "type": "double*"
+        },
+        {
+          "name": "link_max",
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double* link_min,double* link_max)",
+      "call_args": "(axis,link_min,link_max)",
+      "cimguiname": "ImPlot_SetNextAxisLinks",
+      "defaults": {},
+      "funcname": "SetNextAxisLinks",
+      "location": "implot:786",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextAxisLinks",
+      "ret": "void",
+      "signature": "(ImAxis,double*,double*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextAxisToFit": [
+    {
+      "args": "(ImAxis axis)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis)",
+      "call_args": "(axis)",
+      "cimguiname": "ImPlot_SetNextAxisToFit",
+      "defaults": {},
+      "funcname": "SetNextAxisToFit",
+      "location": "implot:788",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextAxisToFit",
+      "ret": "void",
+      "signature": "(ImAxis)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextErrorBarStyle": [
+    {
+      "args": "(const ImVec4 col,float size,float weight)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "weight",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col=ImVec4(0,0,0,-1),float size=-1,float weight=-1)",
+      "call_args": "(col,size,weight)",
+      "cimguiname": "ImPlot_SetNextErrorBarStyle",
+      "defaults": {
+        "col": "ImVec4(0,0,0,-1)",
+        "size": "-1",
+        "weight": "-1"
+      },
+      "funcname": "SetNextErrorBarStyle",
+      "location": "implot:1113",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextErrorBarStyle",
+      "ret": "void",
+      "signature": "(const ImVec4,float,float)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextFillStyle": [
+    {
+      "args": "(const ImVec4 col,float alpha_mod)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "alpha_mod",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col=ImVec4(0,0,0,-1),float alpha_mod=-1)",
+      "call_args": "(col,alpha_mod)",
+      "cimguiname": "ImPlot_SetNextFillStyle",
+      "defaults": {
+        "alpha_mod": "-1",
+        "col": "ImVec4(0,0,0,-1)"
+      },
+      "funcname": "SetNextFillStyle",
+      "location": "implot:1109",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextFillStyle",
+      "ret": "void",
+      "signature": "(const ImVec4,float)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextLineStyle": [
+    {
+      "args": "(const ImVec4 col,float weight)",
+      "argsT": [
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "weight",
+          "type": "float"
+        }
+      ],
+      "argsoriginal": "(const ImVec4& col=ImVec4(0,0,0,-1),float weight=-1)",
+      "call_args": "(col,weight)",
+      "cimguiname": "ImPlot_SetNextLineStyle",
+      "defaults": {
+        "col": "ImVec4(0,0,0,-1)",
+        "weight": "-1"
+      },
+      "funcname": "SetNextLineStyle",
+      "location": "implot:1107",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextLineStyle",
+      "ret": "void",
+      "signature": "(const ImVec4,float)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetNextMarkerStyle": [
+    {
+      "args": "(ImPlotMarker marker,float size,const ImVec4 fill,float weight,const ImVec4 outline)",
+      "argsT": [
+        {
+          "name": "marker",
+          "type": "ImPlotMarker"
+        },
+        {
+          "name": "size",
+          "type": "float"
+        },
+        {
+          "name": "fill",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "weight",
+          "type": "float"
+        },
+        {
+          "name": "outline",
+          "type": "const ImVec4"
+        }
+      ],
+      "argsoriginal": "(ImPlotMarker marker=-1,float size=-1,const ImVec4& fill=ImVec4(0,0,0,-1),float weight=-1,const ImVec4& outline=ImVec4(0,0,0,-1))",
+      "call_args": "(marker,size,fill,weight,outline)",
+      "cimguiname": "ImPlot_SetNextMarkerStyle",
+      "defaults": {
+        "fill": "ImVec4(0,0,0,-1)",
+        "marker": "-1",
+        "outline": "ImVec4(0,0,0,-1)",
+        "size": "-1",
+        "weight": "-1"
+      },
+      "funcname": "SetNextMarkerStyle",
+      "location": "implot:1111",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetNextMarkerStyle",
+      "ret": "void",
+      "signature": "(ImPlotMarker,float,const ImVec4,float,const ImVec4)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxes": [
+    {
+      "args": "(const char* x_label,const char* y_label,ImPlotAxisFlags x_flags,ImPlotAxisFlags y_flags)",
+      "argsT": [
+        {
+          "name": "x_label",
+          "type": "const char*"
+        },
+        {
+          "name": "y_label",
+          "type": "const char*"
+        },
+        {
+          "name": "x_flags",
+          "type": "ImPlotAxisFlags"
+        },
+        {
+          "name": "y_flags",
+          "type": "ImPlotAxisFlags"
+        }
+      ],
+      "argsoriginal": "(const char* x_label,const char* y_label,ImPlotAxisFlags x_flags=0,ImPlotAxisFlags y_flags=0)",
+      "call_args": "(x_label,y_label,x_flags,y_flags)",
+      "cimguiname": "ImPlot_SetupAxes",
+      "defaults": {
+        "x_flags": "0",
+        "y_flags": "0"
+      },
+      "funcname": "SetupAxes",
+      "location": "implot:747",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxes",
+      "ret": "void",
+      "signature": "(const char*,const char*,ImPlotAxisFlags,ImPlotAxisFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxesLimits": [
+    {
+      "args": "(double x_min,double x_max,double y_min,double y_max,ImPlotCond cond)",
+      "argsT": [
+        {
+          "name": "x_min",
+          "type": "double"
+        },
+        {
+          "name": "x_max",
+          "type": "double"
+        },
+        {
+          "name": "y_min",
+          "type": "double"
+        },
+        {
+          "name": "y_max",
+          "type": "double"
+        },
+        {
+          "name": "cond",
+          "type": "ImPlotCond"
+        }
+      ],
+      "argsoriginal": "(double x_min,double x_max,double y_min,double y_max,ImPlotCond cond=ImPlotCond_Once)",
+      "call_args": "(x_min,x_max,y_min,y_max,cond)",
+      "cimguiname": "ImPlot_SetupAxesLimits",
+      "defaults": {
+        "cond": "ImPlotCond_Once"
+      },
+      "funcname": "SetupAxesLimits",
+      "location": "implot:749",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxesLimits",
+      "ret": "void",
+      "signature": "(double,double,double,double,ImPlotCond)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxis": [
+    {
+      "args": "(ImAxis axis,const char* label,ImPlotAxisFlags flags)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "label",
+          "type": "const char*"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotAxisFlags"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,const char* label=((void*)0),ImPlotAxisFlags flags=0)",
+      "call_args": "(axis,label,flags)",
+      "cimguiname": "ImPlot_SetupAxis",
+      "defaults": {
+        "flags": "0",
+        "label": "NULL"
+      },
+      "funcname": "SetupAxis",
+      "location": "implot:724",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxis",
+      "ret": "void",
+      "signature": "(ImAxis,const char*,ImPlotAxisFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisFormat": [
+    {
+      "args": "(ImAxis axis,const char* fmt)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,const char* fmt)",
+      "call_args": "(axis,fmt)",
+      "cimguiname": "ImPlot_SetupAxisFormat",
+      "defaults": {},
+      "funcname": "SetupAxisFormat",
+      "location": "implot:730",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisFormat_Str",
+      "ret": "void",
+      "signature": "(ImAxis,const char*)",
+      "stname": ""
+    },
+    {
+      "args": "(ImAxis axis,ImPlotFormatter formatter,void* data)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "formatter",
+          "type": "ImPlotFormatter"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,ImPlotFormatter formatter,void* data=((void*)0))",
+      "call_args": "(axis,formatter,data)",
+      "cimguiname": "ImPlot_SetupAxisFormat",
+      "defaults": {
+        "data": "NULL"
+      },
+      "funcname": "SetupAxisFormat",
+      "location": "implot:732",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisFormat_PlotFormatter",
+      "ret": "void",
+      "signature": "(ImAxis,ImPlotFormatter,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisLimits": [
+    {
+      "args": "(ImAxis axis,double v_min,double v_max,ImPlotCond cond)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "v_min",
+          "type": "double"
+        },
+        {
+          "name": "v_max",
+          "type": "double"
+        },
+        {
+          "name": "cond",
+          "type": "ImPlotCond"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double v_min,double v_max,ImPlotCond cond=ImPlotCond_Once)",
+      "call_args": "(axis,v_min,v_max,cond)",
+      "cimguiname": "ImPlot_SetupAxisLimits",
+      "defaults": {
+        "cond": "ImPlotCond_Once"
+      },
+      "funcname": "SetupAxisLimits",
+      "location": "implot:726",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisLimits",
+      "ret": "void",
+      "signature": "(ImAxis,double,double,ImPlotCond)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisLimitsConstraints": [
+    {
+      "args": "(ImAxis axis,double v_min,double v_max)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "v_min",
+          "type": "double"
+        },
+        {
+          "name": "v_max",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double v_min,double v_max)",
+      "call_args": "(axis,v_min,v_max)",
+      "cimguiname": "ImPlot_SetupAxisLimitsConstraints",
+      "defaults": {},
+      "funcname": "SetupAxisLimitsConstraints",
+      "location": "implot:742",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisLimitsConstraints",
+      "ret": "void",
+      "signature": "(ImAxis,double,double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisLinks": [
+    {
+      "args": "(ImAxis axis,double* link_min,double* link_max)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "link_min",
+          "type": "double*"
+        },
+        {
+          "name": "link_max",
+          "type": "double*"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double* link_min,double* link_max)",
+      "call_args": "(axis,link_min,link_max)",
+      "cimguiname": "ImPlot_SetupAxisLinks",
+      "defaults": {},
+      "funcname": "SetupAxisLinks",
+      "location": "implot:728",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisLinks",
+      "ret": "void",
+      "signature": "(ImAxis,double*,double*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisScale": [
+    {
+      "args": "(ImAxis axis,ImPlotScale scale)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "scale",
+          "type": "ImPlotScale"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,ImPlotScale scale)",
+      "call_args": "(axis,scale)",
+      "cimguiname": "ImPlot_SetupAxisScale",
+      "defaults": {},
+      "funcname": "SetupAxisScale",
+      "location": "implot:738",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisScale_PlotScale",
+      "ret": "void",
+      "signature": "(ImAxis,ImPlotScale)",
+      "stname": ""
+    },
+    {
+      "args": "(ImAxis axis,ImPlotTransform forward,ImPlotTransform inverse,void* data)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "forward",
+          "type": "ImPlotTransform"
+        },
+        {
+          "name": "inverse",
+          "type": "ImPlotTransform"
+        },
+        {
+          "name": "data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,ImPlotTransform forward,ImPlotTransform inverse,void* data=((void*)0))",
+      "call_args": "(axis,forward,inverse,data)",
+      "cimguiname": "ImPlot_SetupAxisScale",
+      "defaults": {
+        "data": "NULL"
+      },
+      "funcname": "SetupAxisScale",
+      "location": "implot:740",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisScale_PlotTransform",
+      "ret": "void",
+      "signature": "(ImAxis,ImPlotTransform,ImPlotTransform,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisTicks": [
+    {
+      "args": "(ImAxis axis,const double* values,int n_ticks,const char* const labels[],bool keep_default)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "values",
+          "type": "const double*"
+        },
+        {
+          "name": "n_ticks",
+          "type": "int"
+        },
+        {
+          "name": "labels",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "keep_default",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,const double* values,int n_ticks,const char* const labels[]=((void*)0),bool keep_default=false)",
+      "call_args": "(axis,values,n_ticks,labels,keep_default)",
+      "cimguiname": "ImPlot_SetupAxisTicks",
+      "defaults": {
+        "keep_default": "false",
+        "labels": "NULL"
+      },
+      "funcname": "SetupAxisTicks",
+      "location": "implot:734",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisTicks_doublePtr",
+      "ret": "void",
+      "signature": "(ImAxis,const double*,int,const char* const[],bool)",
+      "stname": ""
+    },
+    {
+      "args": "(ImAxis axis,double v_min,double v_max,int n_ticks,const char* const labels[],bool keep_default)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "v_min",
+          "type": "double"
+        },
+        {
+          "name": "v_max",
+          "type": "double"
+        },
+        {
+          "name": "n_ticks",
+          "type": "int"
+        },
+        {
+          "name": "labels",
+          "type": "const char* const[]"
+        },
+        {
+          "name": "keep_default",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double v_min,double v_max,int n_ticks,const char* const labels[]=((void*)0),bool keep_default=false)",
+      "call_args": "(axis,v_min,v_max,n_ticks,labels,keep_default)",
+      "cimguiname": "ImPlot_SetupAxisTicks",
+      "defaults": {
+        "keep_default": "false",
+        "labels": "NULL"
+      },
+      "funcname": "SetupAxisTicks",
+      "location": "implot:736",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisTicks_double",
+      "ret": "void",
+      "signature": "(ImAxis,double,double,int,const char* const[],bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupAxisZoomConstraints": [
+    {
+      "args": "(ImAxis axis,double z_min,double z_max)",
+      "argsT": [
+        {
+          "name": "axis",
+          "type": "ImAxis"
+        },
+        {
+          "name": "z_min",
+          "type": "double"
+        },
+        {
+          "name": "z_max",
+          "type": "double"
+        }
+      ],
+      "argsoriginal": "(ImAxis axis,double z_min,double z_max)",
+      "call_args": "(axis,z_min,z_max)",
+      "cimguiname": "ImPlot_SetupAxisZoomConstraints",
+      "defaults": {},
+      "funcname": "SetupAxisZoomConstraints",
+      "location": "implot:744",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupAxisZoomConstraints",
+      "ret": "void",
+      "signature": "(ImAxis,double,double)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupFinish": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_SetupFinish",
+      "defaults": {},
+      "funcname": "SetupFinish",
+      "location": "implot:758",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupFinish",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupLegend": [
+    {
+      "args": "(ImPlotLocation location,ImPlotLegendFlags flags)",
+      "argsT": [
+        {
+          "name": "location",
+          "type": "ImPlotLocation"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotLegendFlags"
+        }
+      ],
+      "argsoriginal": "(ImPlotLocation location,ImPlotLegendFlags flags=0)",
+      "call_args": "(location,flags)",
+      "cimguiname": "ImPlot_SetupLegend",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "SetupLegend",
+      "location": "implot:752",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupLegend",
+      "ret": "void",
+      "signature": "(ImPlotLocation,ImPlotLegendFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupLock": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_SetupLock",
+      "defaults": {},
+      "funcname": "SetupLock",
+      "location": "implot_internal:1294",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupLock",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SetupMouseText": [
+    {
+      "args": "(ImPlotLocation location,ImPlotMouseTextFlags flags)",
+      "argsT": [
+        {
+          "name": "location",
+          "type": "ImPlotLocation"
+        },
+        {
+          "name": "flags",
+          "type": "ImPlotMouseTextFlags"
+        }
+      ],
+      "argsoriginal": "(ImPlotLocation location,ImPlotMouseTextFlags flags=0)",
+      "call_args": "(location,flags)",
+      "cimguiname": "ImPlot_SetupMouseText",
+      "defaults": {
+        "flags": "0"
+      },
+      "funcname": "SetupMouseText",
+      "location": "implot:754",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SetupMouseText",
+      "ret": "void",
+      "signature": "(ImPlotLocation,ImPlotMouseTextFlags)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowAltLegend": [
+    {
+      "args": "(const char* title_id,bool vertical,const ImVec2 size,bool interactable)",
+      "argsT": [
+        {
+          "name": "title_id",
+          "type": "const char*"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        },
+        {
+          "name": "size",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "interactable",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(const char* title_id,bool vertical=true,const ImVec2 size=ImVec2(0,0),bool interactable=true)",
+      "call_args": "(title_id,vertical,size,interactable)",
+      "cimguiname": "ImPlot_ShowAltLegend",
+      "defaults": {
+        "interactable": "true",
+        "size": "ImVec2(0,0)",
+        "vertical": "true"
+      },
+      "funcname": "ShowAltLegend",
+      "location": "implot_internal:1425",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowAltLegend",
+      "ret": "void",
+      "signature": "(const char*,bool,const ImVec2,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowAxisContextMenu": [
+    {
+      "args": "(ImPlotAxis* axis,ImPlotAxis* equal_axis,bool time_allowed)",
+      "argsT": [
+        {
+          "name": "axis",
+          "reftoptr": true,
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "equal_axis",
+          "type": "ImPlotAxis*"
+        },
+        {
+          "name": "time_allowed",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImPlotAxis& axis,ImPlotAxis* equal_axis,bool time_allowed=false)",
+      "call_args": "(*axis,equal_axis,time_allowed)",
+      "cimguiname": "ImPlot_ShowAxisContextMenu",
+      "defaults": {
+        "time_allowed": "false"
+      },
+      "funcname": "ShowAxisContextMenu",
+      "location": "implot_internal:1412",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowAxisContextMenu",
+      "ret": "void",
+      "signature": "(ImPlotAxis*,ImPlotAxis*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowColormapSelector": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "ImPlot_ShowColormapSelector",
+      "defaults": {},
+      "funcname": "ShowColormapSelector",
+      "location": "implot:1220",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowColormapSelector",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowDatePicker": [
+    {
+      "args": "(const char* id,int* level,ImPlotTime* t,const ImPlotTime* t1,const ImPlotTime* t2)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "const char*"
+        },
+        {
+          "name": "level",
+          "type": "int*"
+        },
+        {
+          "name": "t",
+          "type": "ImPlotTime*"
+        },
+        {
+          "name": "t1",
+          "type": "const ImPlotTime*"
+        },
+        {
+          "name": "t2",
+          "type": "const ImPlotTime*"
+        }
+      ],
+      "argsoriginal": "(const char* id,int* level,ImPlotTime* t,const ImPlotTime* t1=((void*)0),const ImPlotTime* t2=((void*)0))",
+      "call_args": "(id,level,t,t1,t2)",
+      "cimguiname": "ImPlot_ShowDatePicker",
+      "defaults": {
+        "t1": "NULL",
+        "t2": "NULL"
+      },
+      "funcname": "ShowDatePicker",
+      "location": "implot_internal:1596",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowDatePicker",
+      "ret": "bool",
+      "signature": "(const char*,int*,ImPlotTime*,const ImPlotTime*,const ImPlotTime*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowDemoWindow": [
+    {
+      "args": "(bool* p_open)",
+      "argsT": [
+        {
+          "name": "p_open",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_open=((void*)0))",
+      "call_args": "(p_open)",
+      "cimguiname": "ImPlot_ShowDemoWindow",
+      "defaults": {
+        "p_open": "NULL"
+      },
+      "funcname": "ShowDemoWindow",
+      "location": "implot:1235",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowDemoWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowInputMapSelector": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "ImPlot_ShowInputMapSelector",
+      "defaults": {},
+      "funcname": "ShowInputMapSelector",
+      "location": "implot:1222",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowInputMapSelector",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowLegendContextMenu": [
+    {
+      "args": "(ImPlotLegend* legend,bool visible)",
+      "argsT": [
+        {
+          "name": "legend",
+          "reftoptr": true,
+          "type": "ImPlotLegend*"
+        },
+        {
+          "name": "visible",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(ImPlotLegend& legend,bool visible)",
+      "call_args": "(*legend,visible)",
+      "cimguiname": "ImPlot_ShowLegendContextMenu",
+      "defaults": {},
+      "funcname": "ShowLegendContextMenu",
+      "location": "implot_internal:1427",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowLegendContextMenu",
+      "ret": "bool",
+      "signature": "(ImPlotLegend*,bool)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowLegendEntries": [
+    {
+      "args": "(ImPlotItemGroup* items,const ImRect legend_bb,bool interactable,const ImVec2 pad,const ImVec2 spacing,bool vertical,ImDrawList* DrawList)",
+      "argsT": [
+        {
+          "name": "items",
+          "reftoptr": true,
+          "type": "ImPlotItemGroup*"
+        },
+        {
+          "name": "legend_bb",
+          "type": "const ImRect"
+        },
+        {
+          "name": "interactable",
+          "type": "bool"
+        },
+        {
+          "name": "pad",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "spacing",
+          "type": "const ImVec2"
+        },
+        {
+          "name": "vertical",
+          "type": "bool"
+        },
+        {
+          "name": "DrawList",
+          "reftoptr": true,
+          "type": "ImDrawList*"
+        }
+      ],
+      "argsoriginal": "(ImPlotItemGroup& items,const ImRect& legend_bb,bool interactable,const ImVec2& pad,const ImVec2& spacing,bool vertical,ImDrawList& DrawList)",
+      "call_args": "(*items,legend_bb,interactable,pad,spacing,vertical,*DrawList)",
+      "cimguiname": "ImPlot_ShowLegendEntries",
+      "defaults": {},
+      "funcname": "ShowLegendEntries",
+      "location": "implot_internal:1423",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowLegendEntries",
+      "ret": "bool",
+      "signature": "(ImPlotItemGroup*,const ImRect,bool,const ImVec2,const ImVec2,bool,ImDrawList*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowMetricsWindow": [
+    {
+      "args": "(bool* p_popen)",
+      "argsT": [
+        {
+          "name": "p_popen",
+          "type": "bool*"
+        }
+      ],
+      "argsoriginal": "(bool* p_popen=((void*)0))",
+      "call_args": "(p_popen)",
+      "cimguiname": "ImPlot_ShowMetricsWindow",
+      "defaults": {
+        "p_popen": "NULL"
+      },
+      "funcname": "ShowMetricsWindow",
+      "location": "implot:1228",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowMetricsWindow",
+      "ret": "void",
+      "signature": "(bool*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowPlotContextMenu": [
+    {
+      "args": "(ImPlotPlot* plot)",
+      "argsT": [
+        {
+          "name": "plot",
+          "reftoptr": true,
+          "type": "ImPlotPlot*"
+        }
+      ],
+      "argsoriginal": "(ImPlotPlot& plot)",
+      "call_args": "(*plot)",
+      "cimguiname": "ImPlot_ShowPlotContextMenu",
+      "defaults": {},
+      "funcname": "ShowPlotContextMenu",
+      "location": "implot_internal:1287",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowPlotContextMenu",
+      "ret": "void",
+      "signature": "(ImPlotPlot*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowStyleEditor": [
+    {
+      "args": "(ImPlotStyle* ref)",
+      "argsT": [
+        {
+          "name": "ref",
+          "type": "ImPlotStyle*"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyle* ref=((void*)0))",
+      "call_args": "(ref)",
+      "cimguiname": "ImPlot_ShowStyleEditor",
+      "defaults": {
+        "ref": "NULL"
+      },
+      "funcname": "ShowStyleEditor",
+      "location": "implot:1224",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowStyleEditor",
+      "ret": "void",
+      "signature": "(ImPlotStyle*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowStyleSelector": [
+    {
+      "args": "(const char* label)",
+      "argsT": [
+        {
+          "name": "label",
+          "type": "const char*"
+        }
+      ],
+      "argsoriginal": "(const char* label)",
+      "call_args": "(label)",
+      "cimguiname": "ImPlot_ShowStyleSelector",
+      "defaults": {},
+      "funcname": "ShowStyleSelector",
+      "location": "implot:1218",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowStyleSelector",
+      "ret": "bool",
+      "signature": "(const char*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowSubplotsContextMenu": [
+    {
+      "args": "(ImPlotSubplot* subplot)",
+      "argsT": [
+        {
+          "name": "subplot",
+          "reftoptr": true,
+          "type": "ImPlotSubplot*"
+        }
+      ],
+      "argsoriginal": "(ImPlotSubplot& subplot)",
+      "call_args": "(*subplot)",
+      "cimguiname": "ImPlot_ShowSubplotsContextMenu",
+      "defaults": {},
+      "funcname": "ShowSubplotsContextMenu",
+      "location": "implot_internal:1308",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowSubplotsContextMenu",
+      "ret": "void",
+      "signature": "(ImPlotSubplot*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowTimePicker": [
+    {
+      "args": "(const char* id,ImPlotTime* t)",
+      "argsT": [
+        {
+          "name": "id",
+          "type": "const char*"
+        },
+        {
+          "name": "t",
+          "type": "ImPlotTime*"
+        }
+      ],
+      "argsoriginal": "(const char* id,ImPlotTime* t)",
+      "call_args": "(id,t)",
+      "cimguiname": "ImPlot_ShowTimePicker",
+      "defaults": {},
+      "funcname": "ShowTimePicker",
+      "location": "implot_internal:1599",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowTimePicker",
+      "ret": "bool",
+      "signature": "(const char*,ImPlotTime*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_ShowUserGuide": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_ShowUserGuide",
+      "defaults": {},
+      "funcname": "ShowUserGuide",
+      "location": "implot:1226",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_ShowUserGuide",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_StyleColorsAuto": [
+    {
+      "args": "(ImPlotStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImPlotStyle*"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "ImPlot_StyleColorsAuto",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsAuto",
+      "location": "implot:1074",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_StyleColorsAuto",
+      "ret": "void",
+      "signature": "(ImPlotStyle*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_StyleColorsClassic": [
+    {
+      "args": "(ImPlotStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImPlotStyle*"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "ImPlot_StyleColorsClassic",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsClassic",
+      "location": "implot:1076",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_StyleColorsClassic",
+      "ret": "void",
+      "signature": "(ImPlotStyle*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_StyleColorsDark": [
+    {
+      "args": "(ImPlotStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImPlotStyle*"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "ImPlot_StyleColorsDark",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsDark",
+      "location": "implot:1078",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_StyleColorsDark",
+      "ret": "void",
+      "signature": "(ImPlotStyle*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_StyleColorsLight": [
+    {
+      "args": "(ImPlotStyle* dst)",
+      "argsT": [
+        {
+          "name": "dst",
+          "type": "ImPlotStyle*"
+        }
+      ],
+      "argsoriginal": "(ImPlotStyle* dst=((void*)0))",
+      "call_args": "(dst)",
+      "cimguiname": "ImPlot_StyleColorsLight",
+      "defaults": {
+        "dst": "NULL"
+      },
+      "funcname": "StyleColorsLight",
+      "location": "implot:1080",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_StyleColorsLight",
+      "ret": "void",
+      "signature": "(ImPlotStyle*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_SubplotNextCell": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImPlot_SubplotNextCell",
+      "defaults": {},
+      "funcname": "SubplotNextCell",
+      "location": "implot_internal:1305",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_SubplotNextCell",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TagX": [
+    {
+      "args": "(double x,const ImVec4 col,bool round)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "round",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double x,const ImVec4& col,bool round=false)",
+      "call_args": "(x,col,round)",
+      "cimguiname": "ImPlot_TagX",
+      "defaults": {
+        "round": "false"
+      },
+      "funcname": "TagX",
+      "location": "implot:937",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TagX_Bool",
+      "ret": "void",
+      "signature": "(double,const ImVec4,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(double x,const ImVec4 col,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(double x,const ImVec4& col,const char* fmt,...)",
+      "call_args": "(x,col,fmt,...)",
+      "cimguiname": "ImPlot_TagX",
+      "defaults": {},
+      "funcname": "TagX",
+      "isvararg": "...)",
+      "location": "implot:938",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TagX_Str",
+      "ret": "void",
+      "signature": "(double,const ImVec4,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TagXV": [
+    {
+      "args": "(double x,const ImVec4 col,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "x",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(double x,const ImVec4& col,const char* fmt,va_list args)",
+      "call_args": "(x,col,fmt,args)",
+      "cimguiname": "ImPlot_TagXV",
+      "defaults": {},
+      "funcname": "TagXV",
+      "location": "implot:939",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TagXV",
+      "ret": "void",
+      "signature": "(double,const ImVec4,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TagY": [
+    {
+      "args": "(double y,const ImVec4 col,bool round)",
+      "argsT": [
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "round",
+          "type": "bool"
+        }
+      ],
+      "argsoriginal": "(double y,const ImVec4& col,bool round=false)",
+      "call_args": "(y,col,round)",
+      "cimguiname": "ImPlot_TagY",
+      "defaults": {
+        "round": "false"
+      },
+      "funcname": "TagY",
+      "location": "implot:942",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TagY_Bool",
+      "ret": "void",
+      "signature": "(double,const ImVec4,bool)",
+      "stname": ""
+    },
+    {
+      "args": "(double y,const ImVec4 col,const char* fmt,...)",
+      "argsT": [
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "...",
+          "type": "..."
+        }
+      ],
+      "argsoriginal": "(double y,const ImVec4& col,const char* fmt,...)",
+      "call_args": "(y,col,fmt,...)",
+      "cimguiname": "ImPlot_TagY",
+      "defaults": {},
+      "funcname": "TagY",
+      "isvararg": "...)",
+      "location": "implot:943",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TagY_Str",
+      "ret": "void",
+      "signature": "(double,const ImVec4,const char*,...)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TagYV": [
+    {
+      "args": "(double y,const ImVec4 col,const char* fmt,va_list args)",
+      "argsT": [
+        {
+          "name": "y",
+          "type": "double"
+        },
+        {
+          "name": "col",
+          "type": "const ImVec4"
+        },
+        {
+          "name": "fmt",
+          "type": "const char*"
+        },
+        {
+          "name": "args",
+          "type": "va_list"
+        }
+      ],
+      "argsoriginal": "(double y,const ImVec4& col,const char* fmt,va_list args)",
+      "call_args": "(y,col,fmt,args)",
+      "cimguiname": "ImPlot_TagYV",
+      "defaults": {},
+      "funcname": "TagYV",
+      "location": "implot:944",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TagYV",
+      "ret": "void",
+      "signature": "(double,const ImVec4,const char*,va_list)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TransformForward_Log10": [
+    {
+      "args": "(double v,void* noname1)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double v,void*)",
+      "call_args": "(v,noname1)",
+      "cimguiname": "ImPlot_TransformForward_Log10",
+      "defaults": {},
+      "funcname": "TransformForward_Log10",
+      "location": "implot_internal:1605",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TransformForward_Log10",
+      "ret": "double",
+      "signature": "(double,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TransformForward_Logit": [
+    {
+      "args": "(double v,void* noname1)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double v,void*)",
+      "call_args": "(v,noname1)",
+      "cimguiname": "ImPlot_TransformForward_Logit",
+      "defaults": {},
+      "funcname": "TransformForward_Logit",
+      "location": "implot_internal:1622",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TransformForward_Logit",
+      "ret": "double",
+      "signature": "(double,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TransformForward_SymLog": [
+    {
+      "args": "(double v,void* noname1)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double v,void*)",
+      "call_args": "(v,noname1)",
+      "cimguiname": "ImPlot_TransformForward_SymLog",
+      "defaults": {},
+      "funcname": "TransformForward_SymLog",
+      "location": "implot_internal:1614",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TransformForward_SymLog",
+      "ret": "double",
+      "signature": "(double,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TransformInverse_Log10": [
+    {
+      "args": "(double v,void* noname1)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double v,void*)",
+      "call_args": "(v,noname1)",
+      "cimguiname": "ImPlot_TransformInverse_Log10",
+      "defaults": {},
+      "funcname": "TransformInverse_Log10",
+      "location": "implot_internal:1610",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TransformInverse_Log10",
+      "ret": "double",
+      "signature": "(double,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TransformInverse_Logit": [
+    {
+      "args": "(double v,void* noname1)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double v,void*)",
+      "call_args": "(v,noname1)",
+      "cimguiname": "ImPlot_TransformInverse_Logit",
+      "defaults": {},
+      "funcname": "TransformInverse_Logit",
+      "location": "implot_internal:1627",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TransformInverse_Logit",
+      "ret": "double",
+      "signature": "(double,void*)",
+      "stname": ""
+    }
+  ],
+  "ImPlot_TransformInverse_SymLog": [
+    {
+      "args": "(double v,void* noname1)",
+      "argsT": [
+        {
+          "name": "v",
+          "type": "double"
+        },
+        {
+          "name": "noname1",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(double v,void*)",
+      "call_args": "(v,noname1)",
+      "cimguiname": "ImPlot_TransformInverse_SymLog",
+      "defaults": {},
+      "funcname": "TransformInverse_SymLog",
+      "location": "implot_internal:1618",
+      "namespace": "ImPlot",
+      "ov_cimguiname": "ImPlot_TransformInverse_SymLog",
+      "ret": "double",
+      "signature": "(double,void*)",
+      "stname": ""
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimplot/structs_and_enums.json b/src/CodeGenerator/definitions/cimplot/structs_and_enums.json
new file mode 100644
index 00000000..9d30b387
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimplot/structs_and_enums.json
@@ -0,0 +1,2526 @@
+{
+  "enums": {
+    "ImAxis_": [
+      {
+        "calc_value": 0,
+        "name": "ImAxis_X1",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImAxis_X2",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImAxis_X3",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImAxis_Y1",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImAxis_Y2",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImAxis_Y3",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImAxis_COUNT",
+        "value": "6"
+      }
+    ],
+    "ImPlotAxisFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotAxisFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotAxisFlags_NoLabel",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotAxisFlags_NoGridLines",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotAxisFlags_NoTickMarks",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotAxisFlags_NoTickLabels",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImPlotAxisFlags_NoInitialFit",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImPlotAxisFlags_NoMenus",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImPlotAxisFlags_NoSideSwitch",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImPlotAxisFlags_NoHighlight",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImPlotAxisFlags_Opposite",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImPlotAxisFlags_Foreground",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotAxisFlags_Invert",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImPlotAxisFlags_AutoFit",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImPlotAxisFlags_RangeFit",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImPlotAxisFlags_PanStretch",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImPlotAxisFlags_LockMin",
+        "value": "1 << 14"
+      },
+      {
+        "calc_value": 32768,
+        "name": "ImPlotAxisFlags_LockMax",
+        "value": "1 << 15"
+      },
+      {
+        "calc_value": 49152,
+        "name": "ImPlotAxisFlags_Lock",
+        "value": "ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImPlotAxisFlags_NoDecorations",
+        "value": "ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels"
+      },
+      {
+        "calc_value": 258,
+        "name": "ImPlotAxisFlags_AuxDefault",
+        "value": "ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_Opposite"
+      }
+    ],
+    "ImPlotBarGroupsFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotBarGroupsFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotBarGroupsFlags_Horizontal",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImPlotBarGroupsFlags_Stacked",
+        "value": "1 << 11"
+      }
+    ],
+    "ImPlotBarsFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotBarsFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotBarsFlags_Horizontal",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotBin_": [
+      {
+        "calc_value": -1,
+        "name": "ImPlotBin_Sqrt",
+        "value": "-1"
+      },
+      {
+        "calc_value": -2,
+        "name": "ImPlotBin_Sturges",
+        "value": "-2"
+      },
+      {
+        "calc_value": -3,
+        "name": "ImPlotBin_Rice",
+        "value": "-3"
+      },
+      {
+        "calc_value": -4,
+        "name": "ImPlotBin_Scott",
+        "value": "-4"
+      }
+    ],
+    "ImPlotCol_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotCol_Line",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotCol_Fill",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotCol_MarkerOutline",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotCol_MarkerFill",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotCol_ErrorBar",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotCol_FrameBg",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotCol_PlotBg",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImPlotCol_PlotBorder",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotCol_LegendBg",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImPlotCol_LegendBorder",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImPlotCol_LegendText",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImPlotCol_TitleText",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ImPlotCol_InlayText",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImPlotCol_AxisText",
+        "value": "13"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImPlotCol_AxisGrid",
+        "value": "14"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImPlotCol_AxisTick",
+        "value": "15"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImPlotCol_AxisBg",
+        "value": "16"
+      },
+      {
+        "calc_value": 17,
+        "name": "ImPlotCol_AxisBgHovered",
+        "value": "17"
+      },
+      {
+        "calc_value": 18,
+        "name": "ImPlotCol_AxisBgActive",
+        "value": "18"
+      },
+      {
+        "calc_value": 19,
+        "name": "ImPlotCol_Selection",
+        "value": "19"
+      },
+      {
+        "calc_value": 20,
+        "name": "ImPlotCol_Crosshairs",
+        "value": "20"
+      },
+      {
+        "calc_value": 21,
+        "name": "ImPlotCol_COUNT",
+        "value": "21"
+      }
+    ],
+    "ImPlotColormapScaleFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotColormapScaleFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotColormapScaleFlags_NoLabel",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotColormapScaleFlags_Opposite",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotColormapScaleFlags_Invert",
+        "value": "1 << 2"
+      }
+    ],
+    "ImPlotColormap_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotColormap_Deep",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotColormap_Dark",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotColormap_Pastel",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotColormap_Paired",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotColormap_Viridis",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotColormap_Plasma",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotColormap_Hot",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImPlotColormap_Cool",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotColormap_Pink",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImPlotColormap_Jet",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImPlotColormap_Twilight",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImPlotColormap_RdBu",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ImPlotColormap_BrBG",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImPlotColormap_PiYG",
+        "value": "13"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImPlotColormap_Spectral",
+        "value": "14"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImPlotColormap_Greys",
+        "value": "15"
+      }
+    ],
+    "ImPlotCond_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotCond_None",
+        "value": "ImGuiCond_None"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotCond_Always",
+        "value": "ImGuiCond_Always"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotCond_Once",
+        "value": "ImGuiCond_Once"
+      }
+    ],
+    "ImPlotDateFmt_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotDateFmt_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotDateFmt_DayMo",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotDateFmt_DayMoYr",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotDateFmt_MoYr",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotDateFmt_Mo",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotDateFmt_Yr",
+        "value": "5"
+      }
+    ],
+    "ImPlotDigitalFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotDigitalFlags_None",
+        "value": "0"
+      }
+    ],
+    "ImPlotDragToolFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotDragToolFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotDragToolFlags_NoCursors",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotDragToolFlags_NoFit",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotDragToolFlags_NoInputs",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotDragToolFlags_Delayed",
+        "value": "1 << 3"
+      }
+    ],
+    "ImPlotDummyFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotDummyFlags_None",
+        "value": "0"
+      }
+    ],
+    "ImPlotErrorBarsFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotErrorBarsFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotErrorBarsFlags_Horizontal",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotFlags_NoTitle",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotFlags_NoLegend",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotFlags_NoMouseText",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotFlags_NoInputs",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImPlotFlags_NoMenus",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImPlotFlags_NoBoxSelect",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImPlotFlags_NoChild",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImPlotFlags_NoFrame",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImPlotFlags_Equal",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImPlotFlags_Crosshairs",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 55,
+        "name": "ImPlotFlags_CanvasOnly",
+        "value": "ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMouseText"
+      }
+    ],
+    "ImPlotHeatmapFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotHeatmapFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotHeatmapFlags_ColMajor",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotHistogramFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotHistogramFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotHistogramFlags_Horizontal",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImPlotHistogramFlags_Cumulative",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImPlotHistogramFlags_Density",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImPlotHistogramFlags_NoOutliers",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImPlotHistogramFlags_ColMajor",
+        "value": "1 << 14"
+      }
+    ],
+    "ImPlotImageFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotImageFlags_None",
+        "value": "0"
+      }
+    ],
+    "ImPlotInfLinesFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotInfLinesFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotInfLinesFlags_Horizontal",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotItemFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotItemFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotItemFlags_NoLegend",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotItemFlags_NoFit",
+        "value": "1 << 1"
+      }
+    ],
+    "ImPlotLegendFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotLegendFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotLegendFlags_NoButtons",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotLegendFlags_NoHighlightItem",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotLegendFlags_NoHighlightAxis",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotLegendFlags_NoMenus",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImPlotLegendFlags_Outside",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImPlotLegendFlags_Horizontal",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImPlotLegendFlags_Sort",
+        "value": "1 << 6"
+      }
+    ],
+    "ImPlotLineFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotLineFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotLineFlags_Segments",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImPlotLineFlags_Loop",
+        "value": "1 << 11"
+      },
+      {
+        "calc_value": 4096,
+        "name": "ImPlotLineFlags_SkipNaN",
+        "value": "1 << 12"
+      },
+      {
+        "calc_value": 8192,
+        "name": "ImPlotLineFlags_NoClip",
+        "value": "1 << 13"
+      },
+      {
+        "calc_value": 16384,
+        "name": "ImPlotLineFlags_Shaded",
+        "value": "1 << 14"
+      }
+    ],
+    "ImPlotLocation_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotLocation_Center",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotLocation_North",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotLocation_South",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotLocation_West",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotLocation_East",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotLocation_NorthWest",
+        "value": "ImPlotLocation_North | ImPlotLocation_West"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImPlotLocation_NorthEast",
+        "value": "ImPlotLocation_North | ImPlotLocation_East"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotLocation_SouthWest",
+        "value": "ImPlotLocation_South | ImPlotLocation_West"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImPlotLocation_SouthEast",
+        "value": "ImPlotLocation_South | ImPlotLocation_East"
+      }
+    ],
+    "ImPlotMarker_": [
+      {
+        "calc_value": -1,
+        "name": "ImPlotMarker_None",
+        "value": "-1"
+      },
+      {
+        "calc_value": 0,
+        "name": "ImPlotMarker_Circle",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotMarker_Square",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotMarker_Diamond",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotMarker_Up",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotMarker_Down",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotMarker_Left",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotMarker_Right",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImPlotMarker_Cross",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotMarker_Plus",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImPlotMarker_Asterisk",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImPlotMarker_COUNT",
+        "value": "10"
+      }
+    ],
+    "ImPlotMouseTextFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotMouseTextFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotMouseTextFlags_NoAuxAxes",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotMouseTextFlags_NoFormat",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotMouseTextFlags_ShowAlways",
+        "value": "1 << 2"
+      }
+    ],
+    "ImPlotPieChartFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotPieChartFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotPieChartFlags_Normalize",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotScale_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotScale_Linear",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotScale_Time",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotScale_Log10",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotScale_SymLog",
+        "value": "3"
+      }
+    ],
+    "ImPlotScatterFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotScatterFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotScatterFlags_NoClip",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotShadedFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotShadedFlags_None",
+        "value": "0"
+      }
+    ],
+    "ImPlotStairsFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotStairsFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotStairsFlags_PreStep",
+        "value": "1 << 10"
+      },
+      {
+        "calc_value": 2048,
+        "name": "ImPlotStairsFlags_Shaded",
+        "value": "1 << 11"
+      }
+    ],
+    "ImPlotStemsFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotStemsFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotStemsFlags_Horizontal",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotStyleVar_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotStyleVar_LineWeight",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotStyleVar_Marker",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotStyleVar_MarkerSize",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotStyleVar_MarkerWeight",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotStyleVar_FillAlpha",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotStyleVar_ErrorBarSize",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotStyleVar_ErrorBarWeight",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImPlotStyleVar_DigitalBitHeight",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotStyleVar_DigitalBitGap",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImPlotStyleVar_PlotBorderSize",
+        "value": "9"
+      },
+      {
+        "calc_value": 10,
+        "name": "ImPlotStyleVar_MinorAlpha",
+        "value": "10"
+      },
+      {
+        "calc_value": 11,
+        "name": "ImPlotStyleVar_MajorTickLen",
+        "value": "11"
+      },
+      {
+        "calc_value": 12,
+        "name": "ImPlotStyleVar_MinorTickLen",
+        "value": "12"
+      },
+      {
+        "calc_value": 13,
+        "name": "ImPlotStyleVar_MajorTickSize",
+        "value": "13"
+      },
+      {
+        "calc_value": 14,
+        "name": "ImPlotStyleVar_MinorTickSize",
+        "value": "14"
+      },
+      {
+        "calc_value": 15,
+        "name": "ImPlotStyleVar_MajorGridSize",
+        "value": "15"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImPlotStyleVar_MinorGridSize",
+        "value": "16"
+      },
+      {
+        "calc_value": 17,
+        "name": "ImPlotStyleVar_PlotPadding",
+        "value": "17"
+      },
+      {
+        "calc_value": 18,
+        "name": "ImPlotStyleVar_LabelPadding",
+        "value": "18"
+      },
+      {
+        "calc_value": 19,
+        "name": "ImPlotStyleVar_LegendPadding",
+        "value": "19"
+      },
+      {
+        "calc_value": 20,
+        "name": "ImPlotStyleVar_LegendInnerPadding",
+        "value": "20"
+      },
+      {
+        "calc_value": 21,
+        "name": "ImPlotStyleVar_LegendSpacing",
+        "value": "21"
+      },
+      {
+        "calc_value": 22,
+        "name": "ImPlotStyleVar_MousePosPadding",
+        "value": "22"
+      },
+      {
+        "calc_value": 23,
+        "name": "ImPlotStyleVar_AnnotationPadding",
+        "value": "23"
+      },
+      {
+        "calc_value": 24,
+        "name": "ImPlotStyleVar_FitPadding",
+        "value": "24"
+      },
+      {
+        "calc_value": 25,
+        "name": "ImPlotStyleVar_PlotDefaultSize",
+        "value": "25"
+      },
+      {
+        "calc_value": 26,
+        "name": "ImPlotStyleVar_PlotMinSize",
+        "value": "26"
+      },
+      {
+        "calc_value": 27,
+        "name": "ImPlotStyleVar_COUNT",
+        "value": "27"
+      }
+    ],
+    "ImPlotSubplotFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotSubplotFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotSubplotFlags_NoTitle",
+        "value": "1 << 0"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotSubplotFlags_NoLegend",
+        "value": "1 << 1"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotSubplotFlags_NoMenus",
+        "value": "1 << 2"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotSubplotFlags_NoResize",
+        "value": "1 << 3"
+      },
+      {
+        "calc_value": 16,
+        "name": "ImPlotSubplotFlags_NoAlign",
+        "value": "1 << 4"
+      },
+      {
+        "calc_value": 32,
+        "name": "ImPlotSubplotFlags_ShareItems",
+        "value": "1 << 5"
+      },
+      {
+        "calc_value": 64,
+        "name": "ImPlotSubplotFlags_LinkRows",
+        "value": "1 << 6"
+      },
+      {
+        "calc_value": 128,
+        "name": "ImPlotSubplotFlags_LinkCols",
+        "value": "1 << 7"
+      },
+      {
+        "calc_value": 256,
+        "name": "ImPlotSubplotFlags_LinkAllX",
+        "value": "1 << 8"
+      },
+      {
+        "calc_value": 512,
+        "name": "ImPlotSubplotFlags_LinkAllY",
+        "value": "1 << 9"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotSubplotFlags_ColMajor",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotTextFlags_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotTextFlags_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1024,
+        "name": "ImPlotTextFlags_Vertical",
+        "value": "1 << 10"
+      }
+    ],
+    "ImPlotTimeFmt_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotTimeFmt_None",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotTimeFmt_Us",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotTimeFmt_SUs",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotTimeFmt_SMs",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotTimeFmt_S",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotTimeFmt_MinSMs",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotTimeFmt_HrMinSMs",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImPlotTimeFmt_HrMinS",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotTimeFmt_HrMin",
+        "value": "8"
+      },
+      {
+        "calc_value": 9,
+        "name": "ImPlotTimeFmt_Hr",
+        "value": "9"
+      }
+    ],
+    "ImPlotTimeUnit_": [
+      {
+        "calc_value": 0,
+        "name": "ImPlotTimeUnit_Us",
+        "value": "0"
+      },
+      {
+        "calc_value": 1,
+        "name": "ImPlotTimeUnit_Ms",
+        "value": "1"
+      },
+      {
+        "calc_value": 2,
+        "name": "ImPlotTimeUnit_S",
+        "value": "2"
+      },
+      {
+        "calc_value": 3,
+        "name": "ImPlotTimeUnit_Min",
+        "value": "3"
+      },
+      {
+        "calc_value": 4,
+        "name": "ImPlotTimeUnit_Hr",
+        "value": "4"
+      },
+      {
+        "calc_value": 5,
+        "name": "ImPlotTimeUnit_Day",
+        "value": "5"
+      },
+      {
+        "calc_value": 6,
+        "name": "ImPlotTimeUnit_Mo",
+        "value": "6"
+      },
+      {
+        "calc_value": 7,
+        "name": "ImPlotTimeUnit_Yr",
+        "value": "7"
+      },
+      {
+        "calc_value": 8,
+        "name": "ImPlotTimeUnit_COUNT",
+        "value": "8"
+      }
+    ]
+  },
+  "enumtypes": [],
+  "locations": {
+    "Formatter_Time_Data": "implot_internal:1649",
+    "ImAxis_": "implot:116",
+    "ImPlotAlignmentData": "implot_internal:920",
+    "ImPlotAnnotation": "implot_internal:433",
+    "ImPlotAnnotationCollection": "implot_internal:448",
+    "ImPlotAxis": "implot_internal:628",
+    "ImPlotAxisFlags_": "implot:146",
+    "ImPlotBarGroupsFlags_": "implot:264",
+    "ImPlotBarsFlags_": "implot:258",
+    "ImPlotBin_": "implot:459",
+    "ImPlotCol_": "implot:340",
+    "ImPlotColormapData": "implot_internal:323",
+    "ImPlotColormapScaleFlags_": "implot:215",
+    "ImPlotColormap_": "implot:426",
+    "ImPlotCond_": "implot:332",
+    "ImPlotContext": "implot_internal:1205",
+    "ImPlotDateFmt_": "implot_internal:249",
+    "ImPlotDateTimeSpec": "implot_internal:282",
+    "ImPlotDigitalFlags_": "implot:311",
+    "ImPlotDragToolFlags_": "implot:206",
+    "ImPlotDummyFlags_": "implot:327",
+    "ImPlotErrorBarsFlags_": "implot:271",
+    "ImPlotFlags_": "implot:130",
+    "ImPlotHeatmapFlags_": "implot:295",
+    "ImPlotHistogramFlags_": "implot:301",
+    "ImPlotImageFlags_": "implot:316",
+    "ImPlotInfLinesFlags_": "implot:283",
+    "ImPlotInputMap": "implot:556",
+    "ImPlotItem": "implot_internal:943",
+    "ImPlotItemFlags_": "implot:223",
+    "ImPlotItemGroup": "implot_internal:990",
+    "ImPlotLegend": "implot_internal:966",
+    "ImPlotLegendFlags_": "implot:186",
+    "ImPlotLineFlags_": "implot:230",
+    "ImPlotLocation_": "implot:446",
+    "ImPlotMarker_": "implot:410",
+    "ImPlotMouseTextFlags_": "implot:198",
+    "ImPlotNextItemData": "implot_internal:1176",
+    "ImPlotNextPlotData": "implot_internal:1154",
+    "ImPlotPieChartFlags_": "implot:289",
+    "ImPlotPlot": "implot_internal:1013",
+    "ImPlotPoint": "implot:467",
+    "ImPlotPointError": "implot_internal:425",
+    "ImPlotRange": "implot:481",
+    "ImPlotRect": "implot:491",
+    "ImPlotScale_": "implot:402",
+    "ImPlotScatterFlags_": "implot:240",
+    "ImPlotShadedFlags_": "implot:253",
+    "ImPlotStairsFlags_": "implot:246",
+    "ImPlotStemsFlags_": "implot:277",
+    "ImPlotStyle": "implot:505",
+    "ImPlotStyleVar_": "implot:368",
+    "ImPlotSubplot": "implot_internal:1118",
+    "ImPlotSubplotFlags_": "implot:170",
+    "ImPlotTag": "implot_internal:487",
+    "ImPlotTagCollection": "implot_internal:495",
+    "ImPlotTextFlags_": "implot:321",
+    "ImPlotTick": "implot_internal:536",
+    "ImPlotTicker": "implot_internal:558",
+    "ImPlotTime": "implot_internal:297",
+    "ImPlotTimeFmt_": "implot_internal:258",
+    "ImPlotTimeUnit_": "implot_internal:237"
+  },
+  "structs": {
+    "Formatter_Time_Data": [
+      {
+        "name": "Time",
+        "type": "ImPlotTime"
+      },
+      {
+        "name": "Spec",
+        "type": "ImPlotDateTimeSpec"
+      },
+      {
+        "name": "UserFormatter",
+        "type": "ImPlotFormatter"
+      },
+      {
+        "name": "UserFormatterData",
+        "type": "void*"
+      }
+    ],
+    "ImPlotAlignmentData": [
+      {
+        "name": "Vertical",
+        "type": "bool"
+      },
+      {
+        "name": "PadA",
+        "type": "float"
+      },
+      {
+        "name": "PadB",
+        "type": "float"
+      },
+      {
+        "name": "PadAMax",
+        "type": "float"
+      },
+      {
+        "name": "PadBMax",
+        "type": "float"
+      }
+    ],
+    "ImPlotAnnotation": [
+      {
+        "name": "Pos",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Offset",
+        "type": "ImVec2"
+      },
+      {
+        "name": "ColorBg",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorFg",
+        "type": "ImU32"
+      },
+      {
+        "name": "TextOffset",
+        "type": "int"
+      },
+      {
+        "name": "Clamp",
+        "type": "bool"
+      }
+    ],
+    "ImPlotAnnotationCollection": [
+      {
+        "name": "Annotations",
+        "template_type": "ImPlotAnnotation",
+        "type": "ImVector_ImPlotAnnotation"
+      },
+      {
+        "name": "TextBuffer",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "Size",
+        "type": "int"
+      }
+    ],
+    "ImPlotAxis": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImPlotAxisFlags"
+      },
+      {
+        "name": "PreviousFlags",
+        "type": "ImPlotAxisFlags"
+      },
+      {
+        "name": "Range",
+        "type": "ImPlotRange"
+      },
+      {
+        "name": "RangeCond",
+        "type": "ImPlotCond"
+      },
+      {
+        "name": "Scale",
+        "type": "ImPlotScale"
+      },
+      {
+        "name": "FitExtents",
+        "type": "ImPlotRange"
+      },
+      {
+        "name": "OrthoAxis",
+        "type": "ImPlotAxis*"
+      },
+      {
+        "name": "ConstraintRange",
+        "type": "ImPlotRange"
+      },
+      {
+        "name": "ConstraintZoom",
+        "type": "ImPlotRange"
+      },
+      {
+        "name": "Ticker",
+        "type": "ImPlotTicker"
+      },
+      {
+        "name": "Formatter",
+        "type": "ImPlotFormatter"
+      },
+      {
+        "name": "FormatterData",
+        "type": "void*"
+      },
+      {
+        "name": "FormatSpec[16]",
+        "size": 16,
+        "type": "char"
+      },
+      {
+        "name": "Locator",
+        "type": "ImPlotLocator"
+      },
+      {
+        "name": "LinkedMin",
+        "type": "double*"
+      },
+      {
+        "name": "LinkedMax",
+        "type": "double*"
+      },
+      {
+        "name": "PickerLevel",
+        "type": "int"
+      },
+      {
+        "name": "PickerTimeMin",
+        "type": "ImPlotTime"
+      },
+      {
+        "name": "PickerTimeMax",
+        "type": "ImPlotTime"
+      },
+      {
+        "name": "TransformForward",
+        "type": "ImPlotTransform"
+      },
+      {
+        "name": "TransformInverse",
+        "type": "ImPlotTransform"
+      },
+      {
+        "name": "TransformData",
+        "type": "void*"
+      },
+      {
+        "name": "PixelMin",
+        "type": "float"
+      },
+      {
+        "name": "PixelMax",
+        "type": "float"
+      },
+      {
+        "name": "ScaleMin",
+        "type": "double"
+      },
+      {
+        "name": "ScaleMax",
+        "type": "double"
+      },
+      {
+        "name": "ScaleToPixel",
+        "type": "double"
+      },
+      {
+        "name": "Datum1",
+        "type": "float"
+      },
+      {
+        "name": "Datum2",
+        "type": "float"
+      },
+      {
+        "name": "HoverRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "LabelOffset",
+        "type": "int"
+      },
+      {
+        "name": "ColorMaj",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorMin",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorTick",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorTxt",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorBg",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorHov",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorAct",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorHiLi",
+        "type": "ImU32"
+      },
+      {
+        "name": "Enabled",
+        "type": "bool"
+      },
+      {
+        "name": "Vertical",
+        "type": "bool"
+      },
+      {
+        "name": "FitThisFrame",
+        "type": "bool"
+      },
+      {
+        "name": "HasRange",
+        "type": "bool"
+      },
+      {
+        "name": "HasFormatSpec",
+        "type": "bool"
+      },
+      {
+        "name": "ShowDefaultTicks",
+        "type": "bool"
+      },
+      {
+        "name": "Hovered",
+        "type": "bool"
+      },
+      {
+        "name": "Held",
+        "type": "bool"
+      }
+    ],
+    "ImPlotColormapData": [
+      {
+        "name": "Keys",
+        "template_type": "ImU32",
+        "type": "ImVector_ImU32"
+      },
+      {
+        "name": "KeyCounts",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "KeyOffsets",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "Tables",
+        "template_type": "ImU32",
+        "type": "ImVector_ImU32"
+      },
+      {
+        "name": "TableSizes",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "TableOffsets",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "Text",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "TextOffsets",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "Quals",
+        "template_type": "bool",
+        "type": "ImVector_bool"
+      },
+      {
+        "name": "Map",
+        "type": "ImGuiStorage"
+      },
+      {
+        "name": "Count",
+        "type": "int"
+      }
+    ],
+    "ImPlotContext": [
+      {
+        "name": "Plots",
+        "template_type": "ImPlotPlot",
+        "type": "ImPool_ImPlotPlot"
+      },
+      {
+        "name": "Subplots",
+        "template_type": "ImPlotSubplot",
+        "type": "ImPool_ImPlotSubplot"
+      },
+      {
+        "name": "CurrentPlot",
+        "type": "ImPlotPlot*"
+      },
+      {
+        "name": "CurrentSubplot",
+        "type": "ImPlotSubplot*"
+      },
+      {
+        "name": "CurrentItems",
+        "type": "ImPlotItemGroup*"
+      },
+      {
+        "name": "CurrentItem",
+        "type": "ImPlotItem*"
+      },
+      {
+        "name": "PreviousItem",
+        "type": "ImPlotItem*"
+      },
+      {
+        "name": "CTicker",
+        "type": "ImPlotTicker"
+      },
+      {
+        "name": "Annotations",
+        "type": "ImPlotAnnotationCollection"
+      },
+      {
+        "name": "Tags",
+        "type": "ImPlotTagCollection"
+      },
+      {
+        "name": "ChildWindowMade",
+        "type": "bool"
+      },
+      {
+        "name": "Style",
+        "type": "ImPlotStyle"
+      },
+      {
+        "name": "ColorModifiers",
+        "template_type": "ImGuiColorMod",
+        "type": "ImVector_ImGuiColorMod"
+      },
+      {
+        "name": "StyleModifiers",
+        "template_type": "ImGuiStyleMod",
+        "type": "ImVector_ImGuiStyleMod"
+      },
+      {
+        "name": "ColormapData",
+        "type": "ImPlotColormapData"
+      },
+      {
+        "name": "ColormapModifiers",
+        "template_type": "ImPlotColormap",
+        "type": "ImVector_ImPlotColormap"
+      },
+      {
+        "name": "Tm",
+        "type": "tm"
+      },
+      {
+        "name": "TempDouble1",
+        "template_type": "double",
+        "type": "ImVector_double"
+      },
+      {
+        "name": "TempDouble2",
+        "template_type": "double",
+        "type": "ImVector_double"
+      },
+      {
+        "name": "TempInt1",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "DigitalPlotItemCnt",
+        "type": "int"
+      },
+      {
+        "name": "DigitalPlotOffset",
+        "type": "int"
+      },
+      {
+        "name": "NextPlotData",
+        "type": "ImPlotNextPlotData"
+      },
+      {
+        "name": "NextItemData",
+        "type": "ImPlotNextItemData"
+      },
+      {
+        "name": "InputMap",
+        "type": "ImPlotInputMap"
+      },
+      {
+        "name": "OpenContextThisFrame",
+        "type": "bool"
+      },
+      {
+        "name": "MousePosStringBuilder",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "SortItems",
+        "type": "ImPlotItemGroup*"
+      },
+      {
+        "name": "AlignmentData",
+        "template_type": "ImPlotAlignmentData",
+        "type": "ImPool_ImPlotAlignmentData"
+      },
+      {
+        "name": "CurrentAlignmentH",
+        "type": "ImPlotAlignmentData*"
+      },
+      {
+        "name": "CurrentAlignmentV",
+        "type": "ImPlotAlignmentData*"
+      }
+    ],
+    "ImPlotDateTimeSpec": [
+      {
+        "name": "Date",
+        "type": "ImPlotDateFmt"
+      },
+      {
+        "name": "Time",
+        "type": "ImPlotTimeFmt"
+      },
+      {
+        "name": "UseISO8601",
+        "type": "bool"
+      },
+      {
+        "name": "Use24HourClock",
+        "type": "bool"
+      }
+    ],
+    "ImPlotInputMap": [
+      {
+        "name": "Pan",
+        "type": "ImGuiMouseButton"
+      },
+      {
+        "name": "PanMod",
+        "type": "ImGuiModFlags"
+      },
+      {
+        "name": "Fit",
+        "type": "ImGuiMouseButton"
+      },
+      {
+        "name": "Select",
+        "type": "ImGuiMouseButton"
+      },
+      {
+        "name": "SelectCancel",
+        "type": "ImGuiMouseButton"
+      },
+      {
+        "name": "SelectMod",
+        "type": "ImGuiModFlags"
+      },
+      {
+        "name": "SelectHorzMod",
+        "type": "ImGuiModFlags"
+      },
+      {
+        "name": "SelectVertMod",
+        "type": "ImGuiModFlags"
+      },
+      {
+        "name": "Menu",
+        "type": "ImGuiMouseButton"
+      },
+      {
+        "name": "OverrideMod",
+        "type": "ImGuiModFlags"
+      },
+      {
+        "name": "ZoomMod",
+        "type": "ImGuiModFlags"
+      },
+      {
+        "name": "ZoomRate",
+        "type": "float"
+      }
+    ],
+    "ImPlotItem": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Color",
+        "type": "ImU32"
+      },
+      {
+        "name": "LegendHoverRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "NameOffset",
+        "type": "int"
+      },
+      {
+        "name": "Show",
+        "type": "bool"
+      },
+      {
+        "name": "LegendHovered",
+        "type": "bool"
+      },
+      {
+        "name": "SeenThisFrame",
+        "type": "bool"
+      }
+    ],
+    "ImPlotItemGroup": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Legend",
+        "type": "ImPlotLegend"
+      },
+      {
+        "name": "ItemPool",
+        "template_type": "ImPlotItem",
+        "type": "ImPool_ImPlotItem"
+      },
+      {
+        "name": "ColormapIdx",
+        "type": "int"
+      }
+    ],
+    "ImPlotLegend": [
+      {
+        "name": "Flags",
+        "type": "ImPlotLegendFlags"
+      },
+      {
+        "name": "PreviousFlags",
+        "type": "ImPlotLegendFlags"
+      },
+      {
+        "name": "Location",
+        "type": "ImPlotLocation"
+      },
+      {
+        "name": "PreviousLocation",
+        "type": "ImPlotLocation"
+      },
+      {
+        "name": "Indices",
+        "template_type": "int",
+        "type": "ImVector_int"
+      },
+      {
+        "name": "Labels",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "Rect",
+        "type": "ImRect"
+      },
+      {
+        "name": "Hovered",
+        "type": "bool"
+      },
+      {
+        "name": "Held",
+        "type": "bool"
+      },
+      {
+        "name": "CanGoInside",
+        "type": "bool"
+      }
+    ],
+    "ImPlotNextItemData": [
+      {
+        "name": "Colors[5]",
+        "size": 5,
+        "type": "ImVec4"
+      },
+      {
+        "name": "LineWeight",
+        "type": "float"
+      },
+      {
+        "name": "Marker",
+        "type": "ImPlotMarker"
+      },
+      {
+        "name": "MarkerSize",
+        "type": "float"
+      },
+      {
+        "name": "MarkerWeight",
+        "type": "float"
+      },
+      {
+        "name": "FillAlpha",
+        "type": "float"
+      },
+      {
+        "name": "ErrorBarSize",
+        "type": "float"
+      },
+      {
+        "name": "ErrorBarWeight",
+        "type": "float"
+      },
+      {
+        "name": "DigitalBitHeight",
+        "type": "float"
+      },
+      {
+        "name": "DigitalBitGap",
+        "type": "float"
+      },
+      {
+        "name": "RenderLine",
+        "type": "bool"
+      },
+      {
+        "name": "RenderFill",
+        "type": "bool"
+      },
+      {
+        "name": "RenderMarkerLine",
+        "type": "bool"
+      },
+      {
+        "name": "RenderMarkerFill",
+        "type": "bool"
+      },
+      {
+        "name": "HasHidden",
+        "type": "bool"
+      },
+      {
+        "name": "Hidden",
+        "type": "bool"
+      },
+      {
+        "name": "HiddenCond",
+        "type": "ImPlotCond"
+      }
+    ],
+    "ImPlotNextPlotData": [
+      {
+        "name": "RangeCond[ImAxis_COUNT]",
+        "size": 6,
+        "type": "ImPlotCond"
+      },
+      {
+        "name": "Range[ImAxis_COUNT]",
+        "size": 6,
+        "type": "ImPlotRange"
+      },
+      {
+        "name": "HasRange[ImAxis_COUNT]",
+        "size": 6,
+        "type": "bool"
+      },
+      {
+        "name": "Fit[ImAxis_COUNT]",
+        "size": 6,
+        "type": "bool"
+      },
+      {
+        "name": "LinkedMin[ImAxis_COUNT]",
+        "size": 6,
+        "type": "double*"
+      },
+      {
+        "name": "LinkedMax[ImAxis_COUNT]",
+        "size": 6,
+        "type": "double*"
+      }
+    ],
+    "ImPlotPlot": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImPlotFlags"
+      },
+      {
+        "name": "PreviousFlags",
+        "type": "ImPlotFlags"
+      },
+      {
+        "name": "MouseTextLocation",
+        "type": "ImPlotLocation"
+      },
+      {
+        "name": "MouseTextFlags",
+        "type": "ImPlotMouseTextFlags"
+      },
+      {
+        "name": "Axes[ImAxis_COUNT]",
+        "size": 6,
+        "type": "ImPlotAxis"
+      },
+      {
+        "name": "TextBuffer",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "Items",
+        "type": "ImPlotItemGroup"
+      },
+      {
+        "name": "CurrentX",
+        "type": "ImAxis"
+      },
+      {
+        "name": "CurrentY",
+        "type": "ImAxis"
+      },
+      {
+        "name": "FrameRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "CanvasRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "PlotRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "AxesRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "SelectRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "SelectStart",
+        "type": "ImVec2"
+      },
+      {
+        "name": "TitleOffset",
+        "type": "int"
+      },
+      {
+        "name": "JustCreated",
+        "type": "bool"
+      },
+      {
+        "name": "Initialized",
+        "type": "bool"
+      },
+      {
+        "name": "SetupLocked",
+        "type": "bool"
+      },
+      {
+        "name": "FitThisFrame",
+        "type": "bool"
+      },
+      {
+        "name": "Hovered",
+        "type": "bool"
+      },
+      {
+        "name": "Held",
+        "type": "bool"
+      },
+      {
+        "name": "Selecting",
+        "type": "bool"
+      },
+      {
+        "name": "Selected",
+        "type": "bool"
+      },
+      {
+        "name": "ContextLocked",
+        "type": "bool"
+      }
+    ],
+    "ImPlotPoint": [
+      {
+        "name": "x",
+        "type": "double"
+      },
+      {
+        "name": "y",
+        "type": "double"
+      }
+    ],
+    "ImPlotPointError": [
+      {
+        "name": "X",
+        "type": "double"
+      },
+      {
+        "name": "Y",
+        "type": "double"
+      },
+      {
+        "name": "Neg",
+        "type": "double"
+      },
+      {
+        "name": "Pos",
+        "type": "double"
+      }
+    ],
+    "ImPlotRange": [
+      {
+        "name": "Min",
+        "type": "double"
+      },
+      {
+        "name": "Max",
+        "type": "double"
+      }
+    ],
+    "ImPlotRect": [
+      {
+        "name": "X",
+        "type": "ImPlotRange"
+      },
+      {
+        "name": "Y",
+        "type": "ImPlotRange"
+      }
+    ],
+    "ImPlotStyle": [
+      {
+        "name": "LineWeight",
+        "type": "float"
+      },
+      {
+        "name": "Marker",
+        "type": "int"
+      },
+      {
+        "name": "MarkerSize",
+        "type": "float"
+      },
+      {
+        "name": "MarkerWeight",
+        "type": "float"
+      },
+      {
+        "name": "FillAlpha",
+        "type": "float"
+      },
+      {
+        "name": "ErrorBarSize",
+        "type": "float"
+      },
+      {
+        "name": "ErrorBarWeight",
+        "type": "float"
+      },
+      {
+        "name": "DigitalBitHeight",
+        "type": "float"
+      },
+      {
+        "name": "DigitalBitGap",
+        "type": "float"
+      },
+      {
+        "name": "PlotBorderSize",
+        "type": "float"
+      },
+      {
+        "name": "MinorAlpha",
+        "type": "float"
+      },
+      {
+        "name": "MajorTickLen",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MinorTickLen",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MajorTickSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MinorTickSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MajorGridSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MinorGridSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "PlotPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LabelPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LegendPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LegendInnerPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LegendSpacing",
+        "type": "ImVec2"
+      },
+      {
+        "name": "MousePosPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "AnnotationPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "FitPadding",
+        "type": "ImVec2"
+      },
+      {
+        "name": "PlotDefaultSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "PlotMinSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Colors[ImPlotCol_COUNT]",
+        "size": 21,
+        "type": "ImVec4"
+      },
+      {
+        "name": "Colormap",
+        "type": "ImPlotColormap"
+      },
+      {
+        "name": "UseLocalTime",
+        "type": "bool"
+      },
+      {
+        "name": "UseISO8601",
+        "type": "bool"
+      },
+      {
+        "name": "Use24HourClock",
+        "type": "bool"
+      }
+    ],
+    "ImPlotSubplot": [
+      {
+        "name": "ID",
+        "type": "ImGuiID"
+      },
+      {
+        "name": "Flags",
+        "type": "ImPlotSubplotFlags"
+      },
+      {
+        "name": "PreviousFlags",
+        "type": "ImPlotSubplotFlags"
+      },
+      {
+        "name": "Items",
+        "type": "ImPlotItemGroup"
+      },
+      {
+        "name": "Rows",
+        "type": "int"
+      },
+      {
+        "name": "Cols",
+        "type": "int"
+      },
+      {
+        "name": "CurrentIdx",
+        "type": "int"
+      },
+      {
+        "name": "FrameRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "GridRect",
+        "type": "ImRect"
+      },
+      {
+        "name": "CellSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "RowAlignmentData",
+        "template_type": "ImPlotAlignmentData",
+        "type": "ImVector_ImPlotAlignmentData"
+      },
+      {
+        "name": "ColAlignmentData",
+        "template_type": "ImPlotAlignmentData",
+        "type": "ImVector_ImPlotAlignmentData"
+      },
+      {
+        "name": "RowRatios",
+        "template_type": "float",
+        "type": "ImVector_float"
+      },
+      {
+        "name": "ColRatios",
+        "template_type": "float",
+        "type": "ImVector_float"
+      },
+      {
+        "name": "RowLinkData",
+        "template_type": "ImPlotRange",
+        "type": "ImVector_ImPlotRange"
+      },
+      {
+        "name": "ColLinkData",
+        "template_type": "ImPlotRange",
+        "type": "ImVector_ImPlotRange"
+      },
+      {
+        "name": "TempSizes[2]",
+        "size": 2,
+        "type": "float"
+      },
+      {
+        "name": "FrameHovered",
+        "type": "bool"
+      },
+      {
+        "name": "HasTitle",
+        "type": "bool"
+      }
+    ],
+    "ImPlotTag": [
+      {
+        "name": "Axis",
+        "type": "ImAxis"
+      },
+      {
+        "name": "Value",
+        "type": "double"
+      },
+      {
+        "name": "ColorBg",
+        "type": "ImU32"
+      },
+      {
+        "name": "ColorFg",
+        "type": "ImU32"
+      },
+      {
+        "name": "TextOffset",
+        "type": "int"
+      }
+    ],
+    "ImPlotTagCollection": [
+      {
+        "name": "Tags",
+        "template_type": "ImPlotTag",
+        "type": "ImVector_ImPlotTag"
+      },
+      {
+        "name": "TextBuffer",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "Size",
+        "type": "int"
+      }
+    ],
+    "ImPlotTick": [
+      {
+        "name": "PlotPos",
+        "type": "double"
+      },
+      {
+        "name": "PixelPos",
+        "type": "float"
+      },
+      {
+        "name": "LabelSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "TextOffset",
+        "type": "int"
+      },
+      {
+        "name": "Major",
+        "type": "bool"
+      },
+      {
+        "name": "ShowLabel",
+        "type": "bool"
+      },
+      {
+        "name": "Level",
+        "type": "int"
+      },
+      {
+        "name": "Idx",
+        "type": "int"
+      }
+    ],
+    "ImPlotTicker": [
+      {
+        "name": "Ticks",
+        "template_type": "ImPlotTick",
+        "type": "ImVector_ImPlotTick"
+      },
+      {
+        "name": "TextBuffer",
+        "type": "ImGuiTextBuffer"
+      },
+      {
+        "name": "MaxSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "LateSize",
+        "type": "ImVec2"
+      },
+      {
+        "name": "Levels",
+        "type": "int"
+      }
+    ],
+    "ImPlotTime": [
+      {
+        "name": "S",
+        "type": "time_t"
+      },
+      {
+        "name": "Us",
+        "type": "int"
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/definitions/cimplot/variants.json b/src/CodeGenerator/definitions/cimplot/variants.json
new file mode 100644
index 00000000..8593c62d
--- /dev/null
+++ b/src/CodeGenerator/definitions/cimplot/variants.json
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file
diff --git a/src/CodeGenerator/structs_and_enums.json b/src/CodeGenerator/structs_and_enums.json
deleted file mode 100644
index 6820c9ed..00000000
--- a/src/CodeGenerator/structs_and_enums.json
+++ /dev/null
@@ -1,2764 +0,0 @@
-{
-  "enums": {
-    "ImDrawCornerFlags_": [
-      {
-        "calc_value": 1,
-        "name": "ImDrawCornerFlags_TopLeft",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImDrawCornerFlags_TopRight",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImDrawCornerFlags_BotLeft",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImDrawCornerFlags_BotRight",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 3,
-        "name": "ImDrawCornerFlags_Top",
-        "value": "ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight"
-      },
-      {
-        "calc_value": 12,
-        "name": "ImDrawCornerFlags_Bot",
-        "value": "ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight"
-      },
-      {
-        "calc_value": 5,
-        "name": "ImDrawCornerFlags_Left",
-        "value": "ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft"
-      },
-      {
-        "calc_value": 10,
-        "name": "ImDrawCornerFlags_Right",
-        "value": "ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight"
-      },
-      {
-        "calc_value": 15,
-        "name": "ImDrawCornerFlags_All",
-        "value": "0xF"
-      }
-    ],
-    "ImDrawListFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImDrawListFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImDrawListFlags_AntiAliasedLines",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImDrawListFlags_AntiAliasedFill",
-        "value": "1 << 1"
-      }
-    ],
-    "ImFontAtlasFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImFontAtlasFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImFontAtlasFlags_NoPowerOfTwoHeight",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImFontAtlasFlags_NoMouseCursors",
-        "value": "1 << 1"
-      }
-    ],
-    "ImGuiBackendFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiBackendFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiBackendFlags_HasGamepad",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiBackendFlags_HasMouseCursors",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiBackendFlags_HasSetMousePos",
-        "value": "1 << 2"
-      }
-    ],
-    "ImGuiCol_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiCol_Text",
-        "value": 0
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiCol_TextDisabled",
-        "value": 1
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiCol_WindowBg",
-        "value": 2
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiCol_ChildBg",
-        "value": 3
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiCol_PopupBg",
-        "value": 4
-      },
-      {
-        "calc_value": 5,
-        "name": "ImGuiCol_Border",
-        "value": 5
-      },
-      {
-        "calc_value": 6,
-        "name": "ImGuiCol_BorderShadow",
-        "value": 6
-      },
-      {
-        "calc_value": 7,
-        "name": "ImGuiCol_FrameBg",
-        "value": 7
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiCol_FrameBgHovered",
-        "value": 8
-      },
-      {
-        "calc_value": 9,
-        "name": "ImGuiCol_FrameBgActive",
-        "value": 9
-      },
-      {
-        "calc_value": 10,
-        "name": "ImGuiCol_TitleBg",
-        "value": 10
-      },
-      {
-        "calc_value": 11,
-        "name": "ImGuiCol_TitleBgActive",
-        "value": 11
-      },
-      {
-        "calc_value": 12,
-        "name": "ImGuiCol_TitleBgCollapsed",
-        "value": 12
-      },
-      {
-        "calc_value": 13,
-        "name": "ImGuiCol_MenuBarBg",
-        "value": 13
-      },
-      {
-        "calc_value": 14,
-        "name": "ImGuiCol_ScrollbarBg",
-        "value": 14
-      },
-      {
-        "calc_value": 15,
-        "name": "ImGuiCol_ScrollbarGrab",
-        "value": 15
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiCol_ScrollbarGrabHovered",
-        "value": 16
-      },
-      {
-        "calc_value": 17,
-        "name": "ImGuiCol_ScrollbarGrabActive",
-        "value": 17
-      },
-      {
-        "calc_value": 18,
-        "name": "ImGuiCol_CheckMark",
-        "value": 18
-      },
-      {
-        "calc_value": 19,
-        "name": "ImGuiCol_SliderGrab",
-        "value": 19
-      },
-      {
-        "calc_value": 20,
-        "name": "ImGuiCol_SliderGrabActive",
-        "value": 20
-      },
-      {
-        "calc_value": 21,
-        "name": "ImGuiCol_Button",
-        "value": 21
-      },
-      {
-        "calc_value": 22,
-        "name": "ImGuiCol_ButtonHovered",
-        "value": 22
-      },
-      {
-        "calc_value": 23,
-        "name": "ImGuiCol_ButtonActive",
-        "value": 23
-      },
-      {
-        "calc_value": 24,
-        "name": "ImGuiCol_Header",
-        "value": 24
-      },
-      {
-        "calc_value": 25,
-        "name": "ImGuiCol_HeaderHovered",
-        "value": 25
-      },
-      {
-        "calc_value": 26,
-        "name": "ImGuiCol_HeaderActive",
-        "value": 26
-      },
-      {
-        "calc_value": 27,
-        "name": "ImGuiCol_Separator",
-        "value": 27
-      },
-      {
-        "calc_value": 28,
-        "name": "ImGuiCol_SeparatorHovered",
-        "value": 28
-      },
-      {
-        "calc_value": 29,
-        "name": "ImGuiCol_SeparatorActive",
-        "value": 29
-      },
-      {
-        "calc_value": 30,
-        "name": "ImGuiCol_ResizeGrip",
-        "value": 30
-      },
-      {
-        "calc_value": 31,
-        "name": "ImGuiCol_ResizeGripHovered",
-        "value": 31
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiCol_ResizeGripActive",
-        "value": 32
-      },
-      {
-        "calc_value": 33,
-        "name": "ImGuiCol_Tab",
-        "value": 33
-      },
-      {
-        "calc_value": 34,
-        "name": "ImGuiCol_TabHovered",
-        "value": 34
-      },
-      {
-        "calc_value": 35,
-        "name": "ImGuiCol_TabActive",
-        "value": 35
-      },
-      {
-        "calc_value": 36,
-        "name": "ImGuiCol_TabUnfocused",
-        "value": 36
-      },
-      {
-        "calc_value": 37,
-        "name": "ImGuiCol_TabUnfocusedActive",
-        "value": 37
-      },
-      {
-        "calc_value": 38,
-        "name": "ImGuiCol_PlotLines",
-        "value": 38
-      },
-      {
-        "calc_value": 39,
-        "name": "ImGuiCol_PlotLinesHovered",
-        "value": 39
-      },
-      {
-        "calc_value": 40,
-        "name": "ImGuiCol_PlotHistogram",
-        "value": 40
-      },
-      {
-        "calc_value": 41,
-        "name": "ImGuiCol_PlotHistogramHovered",
-        "value": 41
-      },
-      {
-        "calc_value": 42,
-        "name": "ImGuiCol_TextSelectedBg",
-        "value": 42
-      },
-      {
-        "calc_value": 43,
-        "name": "ImGuiCol_DragDropTarget",
-        "value": 43
-      },
-      {
-        "calc_value": 44,
-        "name": "ImGuiCol_NavHighlight",
-        "value": 44
-      },
-      {
-        "calc_value": 45,
-        "name": "ImGuiCol_NavWindowingHighlight",
-        "value": 45
-      },
-      {
-        "calc_value": 46,
-        "name": "ImGuiCol_NavWindowingDimBg",
-        "value": 46
-      },
-      {
-        "calc_value": 47,
-        "name": "ImGuiCol_ModalWindowDimBg",
-        "value": 47
-      },
-      {
-        "calc_value": 48,
-        "name": "ImGuiCol_COUNT",
-        "value": 48
-      }
-    ],
-    "ImGuiColorEditFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiColorEditFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiColorEditFlags_NoAlpha",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiColorEditFlags_NoPicker",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiColorEditFlags_NoOptions",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiColorEditFlags_NoSmallPreview",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiColorEditFlags_NoInputs",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiColorEditFlags_NoTooltip",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 128,
-        "name": "ImGuiColorEditFlags_NoLabel",
-        "value": "1 << 7"
-      },
-      {
-        "calc_value": 256,
-        "name": "ImGuiColorEditFlags_NoSidePreview",
-        "value": "1 << 8"
-      },
-      {
-        "calc_value": 512,
-        "name": "ImGuiColorEditFlags_NoDragDrop",
-        "value": "1 << 9"
-      },
-      {
-        "calc_value": 65536,
-        "name": "ImGuiColorEditFlags_AlphaBar",
-        "value": "1 << 16"
-      },
-      {
-        "calc_value": 131072,
-        "name": "ImGuiColorEditFlags_AlphaPreview",
-        "value": "1 << 17"
-      },
-      {
-        "calc_value": 262144,
-        "name": "ImGuiColorEditFlags_AlphaPreviewHalf",
-        "value": "1 << 18"
-      },
-      {
-        "calc_value": 524288,
-        "name": "ImGuiColorEditFlags_HDR",
-        "value": "1 << 19"
-      },
-      {
-        "calc_value": 1048576,
-        "name": "ImGuiColorEditFlags_RGB",
-        "value": "1 << 20"
-      },
-      {
-        "calc_value": 2097152,
-        "name": "ImGuiColorEditFlags_HSV",
-        "value": "1 << 21"
-      },
-      {
-        "calc_value": 4194304,
-        "name": "ImGuiColorEditFlags_HEX",
-        "value": "1 << 22"
-      },
-      {
-        "calc_value": 8388608,
-        "name": "ImGuiColorEditFlags_Uint8",
-        "value": "1 << 23"
-      },
-      {
-        "calc_value": 16777216,
-        "name": "ImGuiColorEditFlags_Float",
-        "value": "1 << 24"
-      },
-      {
-        "calc_value": 33554432,
-        "name": "ImGuiColorEditFlags_PickerHueBar",
-        "value": "1 << 25"
-      },
-      {
-        "calc_value": 67108864,
-        "name": "ImGuiColorEditFlags_PickerHueWheel",
-        "value": "1 << 26"
-      },
-      {
-        "calc_value": 7340032,
-        "name": "ImGuiColorEditFlags__InputsMask",
-        "value": "ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_HSV|ImGuiColorEditFlags_HEX"
-      },
-      {
-        "calc_value": 25165824,
-        "name": "ImGuiColorEditFlags__DataTypeMask",
-        "value": "ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float"
-      },
-      {
-        "calc_value": 100663296,
-        "name": "ImGuiColorEditFlags__PickerMask",
-        "value": "ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar"
-      },
-      {
-        "calc_value": 42991616,
-        "name": "ImGuiColorEditFlags__OptionsDefault",
-        "value": "ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_RGB|ImGuiColorEditFlags_PickerHueBar"
-      }
-    ],
-    "ImGuiComboFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiComboFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiComboFlags_PopupAlignLeft",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiComboFlags_HeightSmall",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiComboFlags_HeightRegular",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiComboFlags_HeightLarge",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiComboFlags_HeightLargest",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiComboFlags_NoArrowButton",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiComboFlags_NoPreview",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 30,
-        "name": "ImGuiComboFlags_HeightMask_",
-        "value": "ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest"
-      }
-    ],
-    "ImGuiCond_": [
-      {
-        "calc_value": 1,
-        "name": "ImGuiCond_Always",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiCond_Once",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiCond_FirstUseEver",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiCond_Appearing",
-        "value": "1 << 3"
-      }
-    ],
-    "ImGuiConfigFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiConfigFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiConfigFlags_NavEnableKeyboard",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiConfigFlags_NavEnableGamepad",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiConfigFlags_NavEnableSetMousePos",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiConfigFlags_NavNoCaptureKeyboard",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiConfigFlags_NoMouse",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiConfigFlags_NoMouseCursorChange",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 1048576,
-        "name": "ImGuiConfigFlags_IsSRGB",
-        "value": "1 << 20"
-      },
-      {
-        "calc_value": 2097152,
-        "name": "ImGuiConfigFlags_IsTouchScreen",
-        "value": "1 << 21"
-      }
-    ],
-    "ImGuiDataType_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiDataType_S32",
-        "value": 0
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiDataType_U32",
-        "value": 1
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiDataType_S64",
-        "value": 2
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiDataType_U64",
-        "value": 3
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiDataType_Float",
-        "value": 4
-      },
-      {
-        "calc_value": 5,
-        "name": "ImGuiDataType_Double",
-        "value": 5
-      },
-      {
-        "calc_value": 6,
-        "name": "ImGuiDataType_COUNT",
-        "value": 6
-      }
-    ],
-    "ImGuiDir_": [
-      {
-        "calc_value": -1,
-        "name": "ImGuiDir_None",
-        "value": "-1"
-      },
-      {
-        "calc_value": 0,
-        "name": "ImGuiDir_Left",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiDir_Right",
-        "value": "1"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiDir_Up",
-        "value": "2"
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiDir_Down",
-        "value": "3"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiDir_COUNT",
-        "value": 4
-      }
-    ],
-    "ImGuiDragDropFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiDragDropFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiDragDropFlags_SourceNoPreviewTooltip",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiDragDropFlags_SourceNoDisableHover",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiDragDropFlags_SourceNoHoldToOpenOthers",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiDragDropFlags_SourceAllowNullID",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiDragDropFlags_SourceExtern",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiDragDropFlags_SourceAutoExpirePayload",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 1024,
-        "name": "ImGuiDragDropFlags_AcceptBeforeDelivery",
-        "value": "1 << 10"
-      },
-      {
-        "calc_value": 2048,
-        "name": "ImGuiDragDropFlags_AcceptNoDrawDefaultRect",
-        "value": "1 << 11"
-      },
-      {
-        "calc_value": 4096,
-        "name": "ImGuiDragDropFlags_AcceptNoPreviewTooltip",
-        "value": "1 << 12"
-      },
-      {
-        "calc_value": 3072,
-        "name": "ImGuiDragDropFlags_AcceptPeekOnly",
-        "value": "ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect"
-      }
-    ],
-    "ImGuiFocusedFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiFocusedFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiFocusedFlags_ChildWindows",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiFocusedFlags_RootWindow",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiFocusedFlags_AnyWindow",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiFocusedFlags_RootAndChildWindows",
-        "value": "ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows"
-      }
-    ],
-    "ImGuiHoveredFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiHoveredFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiHoveredFlags_ChildWindows",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiHoveredFlags_RootWindow",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiHoveredFlags_AnyWindow",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiHoveredFlags_AllowWhenBlockedByPopup",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiHoveredFlags_AllowWhenBlockedByActiveItem",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiHoveredFlags_AllowWhenOverlapped",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 128,
-        "name": "ImGuiHoveredFlags_AllowWhenDisabled",
-        "value": "1 << 7"
-      },
-      {
-        "calc_value": 104,
-        "name": "ImGuiHoveredFlags_RectOnly",
-        "value": "ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped"
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiHoveredFlags_RootAndChildWindows",
-        "value": "ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows"
-      }
-    ],
-    "ImGuiInputTextFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiInputTextFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiInputTextFlags_CharsDecimal",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiInputTextFlags_CharsHexadecimal",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiInputTextFlags_CharsUppercase",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiInputTextFlags_CharsNoBlank",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiInputTextFlags_AutoSelectAll",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiInputTextFlags_EnterReturnsTrue",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiInputTextFlags_CallbackCompletion",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 128,
-        "name": "ImGuiInputTextFlags_CallbackHistory",
-        "value": "1 << 7"
-      },
-      {
-        "calc_value": 256,
-        "name": "ImGuiInputTextFlags_CallbackAlways",
-        "value": "1 << 8"
-      },
-      {
-        "calc_value": 512,
-        "name": "ImGuiInputTextFlags_CallbackCharFilter",
-        "value": "1 << 9"
-      },
-      {
-        "calc_value": 1024,
-        "name": "ImGuiInputTextFlags_AllowTabInput",
-        "value": "1 << 10"
-      },
-      {
-        "calc_value": 2048,
-        "name": "ImGuiInputTextFlags_CtrlEnterForNewLine",
-        "value": "1 << 11"
-      },
-      {
-        "calc_value": 4096,
-        "name": "ImGuiInputTextFlags_NoHorizontalScroll",
-        "value": "1 << 12"
-      },
-      {
-        "calc_value": 8192,
-        "name": "ImGuiInputTextFlags_AlwaysInsertMode",
-        "value": "1 << 13"
-      },
-      {
-        "calc_value": 16384,
-        "name": "ImGuiInputTextFlags_ReadOnly",
-        "value": "1 << 14"
-      },
-      {
-        "calc_value": 32768,
-        "name": "ImGuiInputTextFlags_Password",
-        "value": "1 << 15"
-      },
-      {
-        "calc_value": 65536,
-        "name": "ImGuiInputTextFlags_NoUndoRedo",
-        "value": "1 << 16"
-      },
-      {
-        "calc_value": 131072,
-        "name": "ImGuiInputTextFlags_CharsScientific",
-        "value": "1 << 17"
-      },
-      {
-        "calc_value": 262144,
-        "name": "ImGuiInputTextFlags_CallbackResize",
-        "value": "1 << 18"
-      },
-      {
-        "calc_value": 1048576,
-        "name": "ImGuiInputTextFlags_Multiline",
-        "value": "1 << 20"
-      }
-    ],
-    "ImGuiKey_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiKey_Tab",
-        "value": 0
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiKey_LeftArrow",
-        "value": 1
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiKey_RightArrow",
-        "value": 2
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiKey_UpArrow",
-        "value": 3
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiKey_DownArrow",
-        "value": 4
-      },
-      {
-        "calc_value": 5,
-        "name": "ImGuiKey_PageUp",
-        "value": 5
-      },
-      {
-        "calc_value": 6,
-        "name": "ImGuiKey_PageDown",
-        "value": 6
-      },
-      {
-        "calc_value": 7,
-        "name": "ImGuiKey_Home",
-        "value": 7
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiKey_End",
-        "value": 8
-      },
-      {
-        "calc_value": 9,
-        "name": "ImGuiKey_Insert",
-        "value": 9
-      },
-      {
-        "calc_value": 10,
-        "name": "ImGuiKey_Delete",
-        "value": 10
-      },
-      {
-        "calc_value": 11,
-        "name": "ImGuiKey_Backspace",
-        "value": 11
-      },
-      {
-        "calc_value": 12,
-        "name": "ImGuiKey_Space",
-        "value": 12
-      },
-      {
-        "calc_value": 13,
-        "name": "ImGuiKey_Enter",
-        "value": 13
-      },
-      {
-        "calc_value": 14,
-        "name": "ImGuiKey_Escape",
-        "value": 14
-      },
-      {
-        "calc_value": 15,
-        "name": "ImGuiKey_A",
-        "value": 15
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiKey_C",
-        "value": 16
-      },
-      {
-        "calc_value": 17,
-        "name": "ImGuiKey_V",
-        "value": 17
-      },
-      {
-        "calc_value": 18,
-        "name": "ImGuiKey_X",
-        "value": 18
-      },
-      {
-        "calc_value": 19,
-        "name": "ImGuiKey_Y",
-        "value": 19
-      },
-      {
-        "calc_value": 20,
-        "name": "ImGuiKey_Z",
-        "value": 20
-      },
-      {
-        "calc_value": 21,
-        "name": "ImGuiKey_COUNT",
-        "value": 21
-      }
-    ],
-    "ImGuiMouseCursor_": [
-      {
-        "calc_value": -1,
-        "name": "ImGuiMouseCursor_None",
-        "value": "-1"
-      },
-      {
-        "calc_value": 0,
-        "name": "ImGuiMouseCursor_Arrow",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiMouseCursor_TextInput",
-        "value": 1
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiMouseCursor_ResizeAll",
-        "value": 2
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiMouseCursor_ResizeNS",
-        "value": 3
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiMouseCursor_ResizeEW",
-        "value": 4
-      },
-      {
-        "calc_value": 5,
-        "name": "ImGuiMouseCursor_ResizeNESW",
-        "value": 5
-      },
-      {
-        "calc_value": 6,
-        "name": "ImGuiMouseCursor_ResizeNWSE",
-        "value": 6
-      },
-      {
-        "calc_value": 7,
-        "name": "ImGuiMouseCursor_Hand",
-        "value": 7
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiMouseCursor_COUNT",
-        "value": 8
-      }
-    ],
-    "ImGuiNavInput_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiNavInput_Activate",
-        "value": 0
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiNavInput_Cancel",
-        "value": 1
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiNavInput_Input",
-        "value": 2
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiNavInput_Menu",
-        "value": 3
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiNavInput_DpadLeft",
-        "value": 4
-      },
-      {
-        "calc_value": 5,
-        "name": "ImGuiNavInput_DpadRight",
-        "value": 5
-      },
-      {
-        "calc_value": 6,
-        "name": "ImGuiNavInput_DpadUp",
-        "value": 6
-      },
-      {
-        "calc_value": 7,
-        "name": "ImGuiNavInput_DpadDown",
-        "value": 7
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiNavInput_LStickLeft",
-        "value": 8
-      },
-      {
-        "calc_value": 9,
-        "name": "ImGuiNavInput_LStickRight",
-        "value": 9
-      },
-      {
-        "calc_value": 10,
-        "name": "ImGuiNavInput_LStickUp",
-        "value": 10
-      },
-      {
-        "calc_value": 11,
-        "name": "ImGuiNavInput_LStickDown",
-        "value": 11
-      },
-      {
-        "calc_value": 12,
-        "name": "ImGuiNavInput_FocusPrev",
-        "value": 12
-      },
-      {
-        "calc_value": 13,
-        "name": "ImGuiNavInput_FocusNext",
-        "value": 13
-      },
-      {
-        "calc_value": 14,
-        "name": "ImGuiNavInput_TweakSlow",
-        "value": 14
-      },
-      {
-        "calc_value": 15,
-        "name": "ImGuiNavInput_TweakFast",
-        "value": 15
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiNavInput_KeyMenu_",
-        "value": 16
-      },
-      {
-        "calc_value": 17,
-        "name": "ImGuiNavInput_KeyLeft_",
-        "value": 17
-      },
-      {
-        "calc_value": 18,
-        "name": "ImGuiNavInput_KeyRight_",
-        "value": 18
-      },
-      {
-        "calc_value": 19,
-        "name": "ImGuiNavInput_KeyUp_",
-        "value": 19
-      },
-      {
-        "calc_value": 20,
-        "name": "ImGuiNavInput_KeyDown_",
-        "value": 20
-      },
-      {
-        "calc_value": 21,
-        "name": "ImGuiNavInput_COUNT",
-        "value": 21
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiNavInput_InternalStart_",
-        "value": "ImGuiNavInput_KeyMenu_"
-      }
-    ],
-    "ImGuiSelectableFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiSelectableFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiSelectableFlags_DontClosePopups",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiSelectableFlags_SpanAllColumns",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiSelectableFlags_AllowDoubleClick",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiSelectableFlags_Disabled",
-        "value": "1 << 3"
-      }
-    ],
-    "ImGuiStyleVar_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiStyleVar_Alpha",
-        "value": 0
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiStyleVar_WindowPadding",
-        "value": 1
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiStyleVar_WindowRounding",
-        "value": 2
-      },
-      {
-        "calc_value": 3,
-        "name": "ImGuiStyleVar_WindowBorderSize",
-        "value": 3
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiStyleVar_WindowMinSize",
-        "value": 4
-      },
-      {
-        "calc_value": 5,
-        "name": "ImGuiStyleVar_WindowTitleAlign",
-        "value": 5
-      },
-      {
-        "calc_value": 6,
-        "name": "ImGuiStyleVar_ChildRounding",
-        "value": 6
-      },
-      {
-        "calc_value": 7,
-        "name": "ImGuiStyleVar_ChildBorderSize",
-        "value": 7
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiStyleVar_PopupRounding",
-        "value": 8
-      },
-      {
-        "calc_value": 9,
-        "name": "ImGuiStyleVar_PopupBorderSize",
-        "value": 9
-      },
-      {
-        "calc_value": 10,
-        "name": "ImGuiStyleVar_FramePadding",
-        "value": 10
-      },
-      {
-        "calc_value": 11,
-        "name": "ImGuiStyleVar_FrameRounding",
-        "value": 11
-      },
-      {
-        "calc_value": 12,
-        "name": "ImGuiStyleVar_FrameBorderSize",
-        "value": 12
-      },
-      {
-        "calc_value": 13,
-        "name": "ImGuiStyleVar_ItemSpacing",
-        "value": 13
-      },
-      {
-        "calc_value": 14,
-        "name": "ImGuiStyleVar_ItemInnerSpacing",
-        "value": 14
-      },
-      {
-        "calc_value": 15,
-        "name": "ImGuiStyleVar_IndentSpacing",
-        "value": 15
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiStyleVar_ScrollbarSize",
-        "value": 16
-      },
-      {
-        "calc_value": 17,
-        "name": "ImGuiStyleVar_ScrollbarRounding",
-        "value": 17
-      },
-      {
-        "calc_value": 18,
-        "name": "ImGuiStyleVar_GrabMinSize",
-        "value": 18
-      },
-      {
-        "calc_value": 19,
-        "name": "ImGuiStyleVar_GrabRounding",
-        "value": 19
-      },
-      {
-        "calc_value": 20,
-        "name": "ImGuiStyleVar_TabRounding",
-        "value": 20
-      },
-      {
-        "calc_value": 21,
-        "name": "ImGuiStyleVar_ButtonTextAlign",
-        "value": 21
-      },
-      {
-        "calc_value": 22,
-        "name": "ImGuiStyleVar_COUNT",
-        "value": 22
-      }
-    ],
-    "ImGuiTabBarFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiTabBarFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiTabBarFlags_Reorderable",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiTabBarFlags_AutoSelectNewTabs",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiTabBarFlags_NoCloseWithMiddleMouseButton",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiTabBarFlags_NoTabListPopupButton",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiTabBarFlags_NoTabListScrollingButtons",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiTabBarFlags_NoTooltip",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiTabBarFlags_FittingPolicyResizeDown",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 128,
-        "name": "ImGuiTabBarFlags_FittingPolicyScroll",
-        "value": "1 << 7"
-      },
-      {
-        "calc_value": 192,
-        "name": "ImGuiTabBarFlags_FittingPolicyMask_",
-        "value": "ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiTabBarFlags_FittingPolicyDefault_",
-        "value": "ImGuiTabBarFlags_FittingPolicyResizeDown"
-      }
-    ],
-    "ImGuiTabItemFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiTabItemFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiTabItemFlags_UnsavedDocument",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiTabItemFlags_SetSelected",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiTabItemFlags_NoCloseWithMiddleMouseButton",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiTabItemFlags_NoPushId",
-        "value": "1 << 3"
-      }
-    ],
-    "ImGuiTreeNodeFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiTreeNodeFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiTreeNodeFlags_Selected",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiTreeNodeFlags_Framed",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiTreeNodeFlags_AllowItemOverlap",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiTreeNodeFlags_NoTreePushOnOpen",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiTreeNodeFlags_NoAutoOpenOnLog",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiTreeNodeFlags_DefaultOpen",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiTreeNodeFlags_OpenOnDoubleClick",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 128,
-        "name": "ImGuiTreeNodeFlags_OpenOnArrow",
-        "value": "1 << 7"
-      },
-      {
-        "calc_value": 256,
-        "name": "ImGuiTreeNodeFlags_Leaf",
-        "value": "1 << 8"
-      },
-      {
-        "calc_value": 512,
-        "name": "ImGuiTreeNodeFlags_Bullet",
-        "value": "1 << 9"
-      },
-      {
-        "calc_value": 1024,
-        "name": "ImGuiTreeNodeFlags_FramePadding",
-        "value": "1 << 10"
-      },
-      {
-        "calc_value": 8192,
-        "name": "ImGuiTreeNodeFlags_NavLeftJumpsBackHere",
-        "value": "1 << 13"
-      },
-      {
-        "calc_value": 26,
-        "name": "ImGuiTreeNodeFlags_CollapsingHeader",
-        "value": "ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog"
-      }
-    ],
-    "ImGuiWindowFlags_": [
-      {
-        "calc_value": 0,
-        "name": "ImGuiWindowFlags_None",
-        "value": "0"
-      },
-      {
-        "calc_value": 1,
-        "name": "ImGuiWindowFlags_NoTitleBar",
-        "value": "1 << 0"
-      },
-      {
-        "calc_value": 2,
-        "name": "ImGuiWindowFlags_NoResize",
-        "value": "1 << 1"
-      },
-      {
-        "calc_value": 4,
-        "name": "ImGuiWindowFlags_NoMove",
-        "value": "1 << 2"
-      },
-      {
-        "calc_value": 8,
-        "name": "ImGuiWindowFlags_NoScrollbar",
-        "value": "1 << 3"
-      },
-      {
-        "calc_value": 16,
-        "name": "ImGuiWindowFlags_NoScrollWithMouse",
-        "value": "1 << 4"
-      },
-      {
-        "calc_value": 32,
-        "name": "ImGuiWindowFlags_NoCollapse",
-        "value": "1 << 5"
-      },
-      {
-        "calc_value": 64,
-        "name": "ImGuiWindowFlags_AlwaysAutoResize",
-        "value": "1 << 6"
-      },
-      {
-        "calc_value": 128,
-        "name": "ImGuiWindowFlags_NoBackground",
-        "value": "1 << 7"
-      },
-      {
-        "calc_value": 256,
-        "name": "ImGuiWindowFlags_NoSavedSettings",
-        "value": "1 << 8"
-      },
-      {
-        "calc_value": 512,
-        "name": "ImGuiWindowFlags_NoMouseInputs",
-        "value": "1 << 9"
-      },
-      {
-        "calc_value": 1024,
-        "name": "ImGuiWindowFlags_MenuBar",
-        "value": "1 << 10"
-      },
-      {
-        "calc_value": 2048,
-        "name": "ImGuiWindowFlags_HorizontalScrollbar",
-        "value": "1 << 11"
-      },
-      {
-        "calc_value": 4096,
-        "name": "ImGuiWindowFlags_NoFocusOnAppearing",
-        "value": "1 << 12"
-      },
-      {
-        "calc_value": 8192,
-        "name": "ImGuiWindowFlags_NoBringToFrontOnFocus",
-        "value": "1 << 13"
-      },
-      {
-        "calc_value": 16384,
-        "name": "ImGuiWindowFlags_AlwaysVerticalScrollbar",
-        "value": "1 << 14"
-      },
-      {
-        "calc_value": 32768,
-        "name": "ImGuiWindowFlags_AlwaysHorizontalScrollbar",
-        "value": "1<< 15"
-      },
-      {
-        "calc_value": 65536,
-        "name": "ImGuiWindowFlags_AlwaysUseWindowPadding",
-        "value": "1 << 16"
-      },
-      {
-        "calc_value": 262144,
-        "name": "ImGuiWindowFlags_NoNavInputs",
-        "value": "1 << 18"
-      },
-      {
-        "calc_value": 524288,
-        "name": "ImGuiWindowFlags_NoNavFocus",
-        "value": "1 << 19"
-      },
-      {
-        "calc_value": 1048576,
-        "name": "ImGuiWindowFlags_UnsavedDocument",
-        "value": "1 << 20"
-      },
-      {
-        "calc_value": 786432,
-        "name": "ImGuiWindowFlags_NoNav",
-        "value": "ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus"
-      },
-      {
-        "calc_value": 43,
-        "name": "ImGuiWindowFlags_NoDecoration",
-        "value": "ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse"
-      },
-      {
-        "calc_value": 786944,
-        "name": "ImGuiWindowFlags_NoInputs",
-        "value": "ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus"
-      },
-      {
-        "calc_value": 8388608,
-        "name": "ImGuiWindowFlags_NavFlattened",
-        "value": "1 << 23"
-      },
-      {
-        "calc_value": 16777216,
-        "name": "ImGuiWindowFlags_ChildWindow",
-        "value": "1 << 24"
-      },
-      {
-        "calc_value": 33554432,
-        "name": "ImGuiWindowFlags_Tooltip",
-        "value": "1 << 25"
-      },
-      {
-        "calc_value": 67108864,
-        "name": "ImGuiWindowFlags_Popup",
-        "value": "1 << 26"
-      },
-      {
-        "calc_value": 134217728,
-        "name": "ImGuiWindowFlags_Modal",
-        "value": "1 << 27"
-      },
-      {
-        "calc_value": 268435456,
-        "name": "ImGuiWindowFlags_ChildMenu",
-        "value": "1 << 28"
-      }
-    ]
-  },
-  "structs": {
-    "CustomRect": [
-      {
-        "name": "ID",
-        "type": "unsigned int"
-      },
-      {
-        "name": "Width",
-        "type": "unsigned short"
-      },
-      {
-        "name": "Height",
-        "type": "unsigned short"
-      },
-      {
-        "name": "X",
-        "type": "unsigned short"
-      },
-      {
-        "name": "Y",
-        "type": "unsigned short"
-      },
-      {
-        "name": "GlyphAdvanceX",
-        "type": "float"
-      },
-      {
-        "name": "GlyphOffset",
-        "type": "ImVec2"
-      },
-      {
-        "name": "Font",
-        "type": "ImFont*"
-      }
-    ],
-    "ImColor": [
-      {
-        "name": "Value",
-        "type": "ImVec4"
-      }
-    ],
-    "ImDrawChannel": [
-      {
-        "name": "CmdBuffer",
-        "template_type": "ImDrawCmd",
-        "type": "ImVector_ImDrawCmd"
-      },
-      {
-        "name": "IdxBuffer",
-        "template_type": "ImDrawIdx",
-        "type": "ImVector_ImDrawIdx"
-      }
-    ],
-    "ImDrawCmd": [
-      {
-        "name": "ElemCount",
-        "type": "unsigned int"
-      },
-      {
-        "name": "ClipRect",
-        "type": "ImVec4"
-      },
-      {
-        "name": "TextureId",
-        "type": "ImTextureID"
-      },
-      {
-        "name": "UserCallback",
-        "type": "ImDrawCallback"
-      },
-      {
-        "name": "UserCallbackData",
-        "type": "void*"
-      }
-    ],
-    "ImDrawData": [
-      {
-        "name": "Valid",
-        "type": "bool"
-      },
-      {
-        "name": "CmdLists",
-        "type": "ImDrawList**"
-      },
-      {
-        "name": "CmdListsCount",
-        "type": "int"
-      },
-      {
-        "name": "TotalIdxCount",
-        "type": "int"
-      },
-      {
-        "name": "TotalVtxCount",
-        "type": "int"
-      },
-      {
-        "name": "DisplayPos",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DisplaySize",
-        "type": "ImVec2"
-      }
-    ],
-    "ImDrawList": [
-      {
-        "name": "CmdBuffer",
-        "template_type": "ImDrawCmd",
-        "type": "ImVector_ImDrawCmd"
-      },
-      {
-        "name": "IdxBuffer",
-        "template_type": "ImDrawIdx",
-        "type": "ImVector_ImDrawIdx"
-      },
-      {
-        "name": "VtxBuffer",
-        "template_type": "ImDrawVert",
-        "type": "ImVector_ImDrawVert"
-      },
-      {
-        "name": "Flags",
-        "type": "ImDrawListFlags"
-      },
-      {
-        "name": "_Data",
-        "type": "const ImDrawListSharedData*"
-      },
-      {
-        "name": "_OwnerName",
-        "type": "const char*"
-      },
-      {
-        "name": "_VtxCurrentIdx",
-        "type": "unsigned int"
-      },
-      {
-        "name": "_VtxWritePtr",
-        "type": "ImDrawVert*"
-      },
-      {
-        "name": "_IdxWritePtr",
-        "type": "ImDrawIdx*"
-      },
-      {
-        "name": "_ClipRectStack",
-        "template_type": "ImVec4",
-        "type": "ImVector_ImVec4"
-      },
-      {
-        "name": "_TextureIdStack",
-        "template_type": "ImTextureID",
-        "type": "ImVector_ImTextureID"
-      },
-      {
-        "name": "_Path",
-        "template_type": "ImVec2",
-        "type": "ImVector_ImVec2"
-      },
-      {
-        "name": "_ChannelsCurrent",
-        "type": "int"
-      },
-      {
-        "name": "_ChannelsCount",
-        "type": "int"
-      },
-      {
-        "name": "_Channels",
-        "template_type": "ImDrawChannel",
-        "type": "ImVector_ImDrawChannel"
-      }
-    ],
-    "ImDrawVert": [
-      {
-        "name": "pos",
-        "type": "ImVec2"
-      },
-      {
-        "name": "uv",
-        "type": "ImVec2"
-      },
-      {
-        "name": "col",
-        "type": "ImU32"
-      }
-    ],
-    "ImFont": [
-      {
-        "name": "FontSize",
-        "type": "float"
-      },
-      {
-        "name": "Scale",
-        "type": "float"
-      },
-      {
-        "name": "DisplayOffset",
-        "type": "ImVec2"
-      },
-      {
-        "name": "Glyphs",
-        "template_type": "ImFontGlyph",
-        "type": "ImVector_ImFontGlyph"
-      },
-      {
-        "name": "IndexAdvanceX",
-        "template_type": "float",
-        "type": "ImVector_float"
-      },
-      {
-        "name": "IndexLookup",
-        "template_type": "ImWchar",
-        "type": "ImVector_ImWchar"
-      },
-      {
-        "name": "FallbackGlyph",
-        "type": "const ImFontGlyph*"
-      },
-      {
-        "name": "FallbackAdvanceX",
-        "type": "float"
-      },
-      {
-        "name": "FallbackChar",
-        "type": "ImWchar"
-      },
-      {
-        "name": "ConfigDataCount",
-        "type": "short"
-      },
-      {
-        "name": "ConfigData",
-        "type": "ImFontConfig*"
-      },
-      {
-        "name": "ContainerAtlas",
-        "type": "ImFontAtlas*"
-      },
-      {
-        "name": "Ascent",
-        "type": "float"
-      },
-      {
-        "name": "Descent",
-        "type": "float"
-      },
-      {
-        "name": "DirtyLookupTables",
-        "type": "bool"
-      },
-      {
-        "name": "MetricsTotalSurface",
-        "type": "int"
-      }
-    ],
-    "ImFontAtlas": [
-      {
-        "name": "Locked",
-        "type": "bool"
-      },
-      {
-        "name": "Flags",
-        "type": "ImFontAtlasFlags"
-      },
-      {
-        "name": "TexID",
-        "type": "ImTextureID"
-      },
-      {
-        "name": "TexDesiredWidth",
-        "type": "int"
-      },
-      {
-        "name": "TexGlyphPadding",
-        "type": "int"
-      },
-      {
-        "name": "TexPixelsAlpha8",
-        "type": "unsigned char*"
-      },
-      {
-        "name": "TexPixelsRGBA32",
-        "type": "unsigned int*"
-      },
-      {
-        "name": "TexWidth",
-        "type": "int"
-      },
-      {
-        "name": "TexHeight",
-        "type": "int"
-      },
-      {
-        "name": "TexUvScale",
-        "type": "ImVec2"
-      },
-      {
-        "name": "TexUvWhitePixel",
-        "type": "ImVec2"
-      },
-      {
-        "name": "Fonts",
-        "template_type": "ImFont*",
-        "type": "ImVector_ImFontPtr"
-      },
-      {
-        "name": "CustomRects",
-        "template_type": "CustomRect",
-        "type": "ImVector_CustomRect"
-      },
-      {
-        "name": "ConfigData",
-        "template_type": "ImFontConfig",
-        "type": "ImVector_ImFontConfig"
-      },
-      {
-        "name": "CustomRectIds[1]",
-        "size": 1,
-        "type": "int"
-      }
-    ],
-    "ImFontConfig": [
-      {
-        "name": "FontData",
-        "type": "void*"
-      },
-      {
-        "name": "FontDataSize",
-        "type": "int"
-      },
-      {
-        "name": "FontDataOwnedByAtlas",
-        "type": "bool"
-      },
-      {
-        "name": "FontNo",
-        "type": "int"
-      },
-      {
-        "name": "SizePixels",
-        "type": "float"
-      },
-      {
-        "name": "OversampleH",
-        "type": "int"
-      },
-      {
-        "name": "OversampleV",
-        "type": "int"
-      },
-      {
-        "name": "PixelSnapH",
-        "type": "bool"
-      },
-      {
-        "name": "GlyphExtraSpacing",
-        "type": "ImVec2"
-      },
-      {
-        "name": "GlyphOffset",
-        "type": "ImVec2"
-      },
-      {
-        "name": "GlyphRanges",
-        "type": "const ImWchar*"
-      },
-      {
-        "name": "GlyphMinAdvanceX",
-        "type": "float"
-      },
-      {
-        "name": "GlyphMaxAdvanceX",
-        "type": "float"
-      },
-      {
-        "name": "MergeMode",
-        "type": "bool"
-      },
-      {
-        "name": "RasterizerFlags",
-        "type": "unsigned int"
-      },
-      {
-        "name": "RasterizerMultiply",
-        "type": "float"
-      },
-      {
-        "name": "Name[40]",
-        "size": 40,
-        "type": "char"
-      },
-      {
-        "name": "DstFont",
-        "type": "ImFont*"
-      }
-    ],
-    "ImFontGlyph": [
-      {
-        "name": "Codepoint",
-        "type": "ImWchar"
-      },
-      {
-        "name": "AdvanceX",
-        "type": "float"
-      },
-      {
-        "name": "X0",
-        "type": "float"
-      },
-      {
-        "name": "Y0",
-        "type": "float"
-      },
-      {
-        "name": "X1",
-        "type": "float"
-      },
-      {
-        "name": "Y1",
-        "type": "float"
-      },
-      {
-        "name": "U0",
-        "type": "float"
-      },
-      {
-        "name": "V0",
-        "type": "float"
-      },
-      {
-        "name": "U1",
-        "type": "float"
-      },
-      {
-        "name": "V1",
-        "type": "float"
-      }
-    ],
-    "ImFontGlyphRangesBuilder": [
-      {
-        "name": "UsedChars",
-        "template_type": "int",
-        "type": "ImVector_int"
-      }
-    ],
-    "ImGuiIO": [
-      {
-        "name": "ConfigFlags",
-        "type": "ImGuiConfigFlags"
-      },
-      {
-        "name": "BackendFlags",
-        "type": "ImGuiBackendFlags"
-      },
-      {
-        "name": "DisplaySize",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DeltaTime",
-        "type": "float"
-      },
-      {
-        "name": "IniSavingRate",
-        "type": "float"
-      },
-      {
-        "name": "IniFilename",
-        "type": "const char*"
-      },
-      {
-        "name": "LogFilename",
-        "type": "const char*"
-      },
-      {
-        "name": "MouseDoubleClickTime",
-        "type": "float"
-      },
-      {
-        "name": "MouseDoubleClickMaxDist",
-        "type": "float"
-      },
-      {
-        "name": "MouseDragThreshold",
-        "type": "float"
-      },
-      {
-        "name": "KeyMap[ImGuiKey_COUNT]",
-        "size": 21,
-        "type": "int"
-      },
-      {
-        "name": "KeyRepeatDelay",
-        "type": "float"
-      },
-      {
-        "name": "KeyRepeatRate",
-        "type": "float"
-      },
-      {
-        "name": "UserData",
-        "type": "void*"
-      },
-      {
-        "name": "Fonts",
-        "type": "ImFontAtlas*"
-      },
-      {
-        "name": "FontGlobalScale",
-        "type": "float"
-      },
-      {
-        "name": "FontAllowUserScaling",
-        "type": "bool"
-      },
-      {
-        "name": "FontDefault",
-        "type": "ImFont*"
-      },
-      {
-        "name": "DisplayFramebufferScale",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DisplayVisibleMin",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DisplayVisibleMax",
-        "type": "ImVec2"
-      },
-      {
-        "name": "MouseDrawCursor",
-        "type": "bool"
-      },
-      {
-        "name": "ConfigMacOSXBehaviors",
-        "type": "bool"
-      },
-      {
-        "name": "ConfigInputTextCursorBlink",
-        "type": "bool"
-      },
-      {
-        "name": "ConfigWindowsResizeFromEdges",
-        "type": "bool"
-      },
-      {
-        "name": "ConfigWindowsMoveFromTitleBarOnly",
-        "type": "bool"
-      },
-      {
-        "name": "BackendPlatformName",
-        "type": "const char*"
-      },
-      {
-        "name": "BackendRendererName",
-        "type": "const char*"
-      },
-      {
-        "name": "BackendPlatformUserData",
-        "type": "void*"
-      },
-      {
-        "name": "BackendRendererUserData",
-        "type": "void*"
-      },
-      {
-        "name": "BackendLanguageUserData",
-        "type": "void*"
-      },
-      {
-        "name": "GetClipboardTextFn",
-        "type": "const char*(*)(void* user_data)"
-      },
-      {
-        "name": "SetClipboardTextFn",
-        "type": "void(*)(void* user_data,const char* text)"
-      },
-      {
-        "name": "ClipboardUserData",
-        "type": "void*"
-      },
-      {
-        "name": "ImeSetInputScreenPosFn",
-        "type": "void(*)(int x,int y)"
-      },
-      {
-        "name": "ImeWindowHandle",
-        "type": "void*"
-      },
-      {
-        "name": "RenderDrawListsFnUnused",
-        "type": "void*"
-      },
-      {
-        "name": "MousePos",
-        "type": "ImVec2"
-      },
-      {
-        "name": "MouseDown[5]",
-        "size": 5,
-        "type": "bool"
-      },
-      {
-        "name": "MouseWheel",
-        "type": "float"
-      },
-      {
-        "name": "MouseWheelH",
-        "type": "float"
-      },
-      {
-        "name": "KeyCtrl",
-        "type": "bool"
-      },
-      {
-        "name": "KeyShift",
-        "type": "bool"
-      },
-      {
-        "name": "KeyAlt",
-        "type": "bool"
-      },
-      {
-        "name": "KeySuper",
-        "type": "bool"
-      },
-      {
-        "name": "KeysDown[512]",
-        "size": 512,
-        "type": "bool"
-      },
-      {
-        "name": "NavInputs[ImGuiNavInput_COUNT]",
-        "size": 21,
-        "type": "float"
-      },
-      {
-        "name": "WantCaptureMouse",
-        "type": "bool"
-      },
-      {
-        "name": "WantCaptureKeyboard",
-        "type": "bool"
-      },
-      {
-        "name": "WantTextInput",
-        "type": "bool"
-      },
-      {
-        "name": "WantSetMousePos",
-        "type": "bool"
-      },
-      {
-        "name": "WantSaveIniSettings",
-        "type": "bool"
-      },
-      {
-        "name": "NavActive",
-        "type": "bool"
-      },
-      {
-        "name": "NavVisible",
-        "type": "bool"
-      },
-      {
-        "name": "Framerate",
-        "type": "float"
-      },
-      {
-        "name": "MetricsRenderVertices",
-        "type": "int"
-      },
-      {
-        "name": "MetricsRenderIndices",
-        "type": "int"
-      },
-      {
-        "name": "MetricsRenderWindows",
-        "type": "int"
-      },
-      {
-        "name": "MetricsActiveWindows",
-        "type": "int"
-      },
-      {
-        "name": "MetricsActiveAllocations",
-        "type": "int"
-      },
-      {
-        "name": "MouseDelta",
-        "type": "ImVec2"
-      },
-      {
-        "name": "MousePosPrev",
-        "type": "ImVec2"
-      },
-      {
-        "name": "MouseClickedPos[5]",
-        "size": 5,
-        "type": "ImVec2"
-      },
-      {
-        "name": "MouseClickedTime[5]",
-        "size": 5,
-        "type": "double"
-      },
-      {
-        "name": "MouseClicked[5]",
-        "size": 5,
-        "type": "bool"
-      },
-      {
-        "name": "MouseDoubleClicked[5]",
-        "size": 5,
-        "type": "bool"
-      },
-      {
-        "name": "MouseReleased[5]",
-        "size": 5,
-        "type": "bool"
-      },
-      {
-        "name": "MouseDownOwned[5]",
-        "size": 5,
-        "type": "bool"
-      },
-      {
-        "name": "MouseDownDuration[5]",
-        "size": 5,
-        "type": "float"
-      },
-      {
-        "name": "MouseDownDurationPrev[5]",
-        "size": 5,
-        "type": "float"
-      },
-      {
-        "name": "MouseDragMaxDistanceAbs[5]",
-        "size": 5,
-        "type": "ImVec2"
-      },
-      {
-        "name": "MouseDragMaxDistanceSqr[5]",
-        "size": 5,
-        "type": "float"
-      },
-      {
-        "name": "KeysDownDuration[512]",
-        "size": 512,
-        "type": "float"
-      },
-      {
-        "name": "KeysDownDurationPrev[512]",
-        "size": 512,
-        "type": "float"
-      },
-      {
-        "name": "NavInputsDownDuration[ImGuiNavInput_COUNT]",
-        "size": 21,
-        "type": "float"
-      },
-      {
-        "name": "NavInputsDownDurationPrev[ImGuiNavInput_COUNT]",
-        "size": 21,
-        "type": "float"
-      },
-      {
-        "name": "InputQueueCharacters",
-        "template_type": "ImWchar",
-        "type": "ImVector_ImWchar"
-      }
-    ],
-    "ImGuiInputTextCallbackData": [
-      {
-        "name": "EventFlag",
-        "type": "ImGuiInputTextFlags"
-      },
-      {
-        "name": "Flags",
-        "type": "ImGuiInputTextFlags"
-      },
-      {
-        "name": "UserData",
-        "type": "void*"
-      },
-      {
-        "name": "EventChar",
-        "type": "ImWchar"
-      },
-      {
-        "name": "EventKey",
-        "type": "ImGuiKey"
-      },
-      {
-        "name": "Buf",
-        "type": "char*"
-      },
-      {
-        "name": "BufTextLen",
-        "type": "int"
-      },
-      {
-        "name": "BufSize",
-        "type": "int"
-      },
-      {
-        "name": "BufDirty",
-        "type": "bool"
-      },
-      {
-        "name": "CursorPos",
-        "type": "int"
-      },
-      {
-        "name": "SelectionStart",
-        "type": "int"
-      },
-      {
-        "name": "SelectionEnd",
-        "type": "int"
-      }
-    ],
-    "ImGuiListClipper": [
-      {
-        "name": "StartPosY",
-        "type": "float"
-      },
-      {
-        "name": "ItemsHeight",
-        "type": "float"
-      },
-      {
-        "name": "ItemsCount",
-        "type": "int"
-      },
-      {
-        "name": "StepNo",
-        "type": "int"
-      },
-      {
-        "name": "DisplayStart",
-        "type": "int"
-      },
-      {
-        "name": "DisplayEnd",
-        "type": "int"
-      }
-    ],
-    "ImGuiOnceUponAFrame": [
-      {
-        "name": "RefFrame",
-        "type": "int"
-      }
-    ],
-    "ImGuiPayload": [
-      {
-        "name": "Data",
-        "type": "void*"
-      },
-      {
-        "name": "DataSize",
-        "type": "int"
-      },
-      {
-        "name": "SourceId",
-        "type": "ImGuiID"
-      },
-      {
-        "name": "SourceParentId",
-        "type": "ImGuiID"
-      },
-      {
-        "name": "DataFrameCount",
-        "type": "int"
-      },
-      {
-        "name": "DataType[32+1]",
-        "size": 33,
-        "type": "char"
-      },
-      {
-        "name": "Preview",
-        "type": "bool"
-      },
-      {
-        "name": "Delivery",
-        "type": "bool"
-      }
-    ],
-    "ImGuiSizeCallbackData": [
-      {
-        "name": "UserData",
-        "type": "void*"
-      },
-      {
-        "name": "Pos",
-        "type": "ImVec2"
-      },
-      {
-        "name": "CurrentSize",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DesiredSize",
-        "type": "ImVec2"
-      }
-    ],
-    "ImGuiStorage": [
-      {
-        "name": "Data",
-        "template_type": "Pair",
-        "type": "ImVector_Pair"
-      }
-    ],
-    "ImGuiStyle": [
-      {
-        "name": "Alpha",
-        "type": "float"
-      },
-      {
-        "name": "WindowPadding",
-        "type": "ImVec2"
-      },
-      {
-        "name": "WindowRounding",
-        "type": "float"
-      },
-      {
-        "name": "WindowBorderSize",
-        "type": "float"
-      },
-      {
-        "name": "WindowMinSize",
-        "type": "ImVec2"
-      },
-      {
-        "name": "WindowTitleAlign",
-        "type": "ImVec2"
-      },
-      {
-        "name": "ChildRounding",
-        "type": "float"
-      },
-      {
-        "name": "ChildBorderSize",
-        "type": "float"
-      },
-      {
-        "name": "PopupRounding",
-        "type": "float"
-      },
-      {
-        "name": "PopupBorderSize",
-        "type": "float"
-      },
-      {
-        "name": "FramePadding",
-        "type": "ImVec2"
-      },
-      {
-        "name": "FrameRounding",
-        "type": "float"
-      },
-      {
-        "name": "FrameBorderSize",
-        "type": "float"
-      },
-      {
-        "name": "ItemSpacing",
-        "type": "ImVec2"
-      },
-      {
-        "name": "ItemInnerSpacing",
-        "type": "ImVec2"
-      },
-      {
-        "name": "TouchExtraPadding",
-        "type": "ImVec2"
-      },
-      {
-        "name": "IndentSpacing",
-        "type": "float"
-      },
-      {
-        "name": "ColumnsMinSpacing",
-        "type": "float"
-      },
-      {
-        "name": "ScrollbarSize",
-        "type": "float"
-      },
-      {
-        "name": "ScrollbarRounding",
-        "type": "float"
-      },
-      {
-        "name": "GrabMinSize",
-        "type": "float"
-      },
-      {
-        "name": "GrabRounding",
-        "type": "float"
-      },
-      {
-        "name": "TabRounding",
-        "type": "float"
-      },
-      {
-        "name": "TabBorderSize",
-        "type": "float"
-      },
-      {
-        "name": "ButtonTextAlign",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DisplayWindowPadding",
-        "type": "ImVec2"
-      },
-      {
-        "name": "DisplaySafeAreaPadding",
-        "type": "ImVec2"
-      },
-      {
-        "name": "MouseCursorScale",
-        "type": "float"
-      },
-      {
-        "name": "AntiAliasedLines",
-        "type": "bool"
-      },
-      {
-        "name": "AntiAliasedFill",
-        "type": "bool"
-      },
-      {
-        "name": "CurveTessellationTol",
-        "type": "float"
-      },
-      {
-        "name": "Colors[ImGuiCol_COUNT]",
-        "size": 48,
-        "type": "ImVec4"
-      }
-    ],
-    "ImGuiTextBuffer": [
-      {
-        "name": "Buf",
-        "template_type": "char",
-        "type": "ImVector_char"
-      }
-    ],
-    "ImGuiTextFilter": [
-      {
-        "name": "InputBuf[256]",
-        "size": 256,
-        "type": "char"
-      },
-      {
-        "name": "Filters",
-        "template_type": "TextRange",
-        "type": "ImVector_TextRange"
-      },
-      {
-        "name": "CountGrep",
-        "type": "int"
-      }
-    ],
-    "ImVec2": [
-      {
-        "name": "x",
-        "type": "float"
-      },
-      {
-        "name": "y",
-        "type": "float"
-      }
-    ],
-    "ImVec4": [
-      {
-        "name": "x",
-        "type": "float"
-      },
-      {
-        "name": "y",
-        "type": "float"
-      },
-      {
-        "name": "z",
-        "type": "float"
-      },
-      {
-        "name": "w",
-        "type": "float"
-      }
-    ],
-    "ImVector": [],
-    "Pair": [
-      {
-        "name": "key",
-        "type": "ImGuiID"
-      },
-      {
-        "name": "}",
-        "type": "union { int val_i; float val_f; void* val_p;"
-      }
-    ],
-    "TextRange": [
-      {
-        "name": "b",
-        "type": "const char*"
-      },
-      {
-        "name": "e",
-        "type": "const char*"
-      }
-    ]
-  }
-}
\ No newline at end of file
diff --git a/src/ImGui.NET.SampleProgram.XNA/ImGui.NET.SampleProgram.XNA.csproj b/src/ImGui.NET.SampleProgram.XNA/ImGui.NET.SampleProgram.XNA.csproj
index 623947d2..9510bea9 100644
--- a/src/ImGui.NET.SampleProgram.XNA/ImGui.NET.SampleProgram.XNA.csproj
+++ b/src/ImGui.NET.SampleProgram.XNA/ImGui.NET.SampleProgram.XNA.csproj
@@ -5,7 +5,7 @@
         <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
         <AssemblyName>ImGuiNET.SampleProgram.XNA</AssemblyName>
         <RootNamespace>ImGuiNET.SampleProgram.XNA</RootNamespace>
-        <TargetFramework>net462</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <OutputType>Exe</OutputType>
     </PropertyGroup>
 
@@ -15,14 +15,12 @@
 
     <ItemGroup>
         <Content Include="$(RepositoryRootDirectory)/deps/cimgui/win-x64/cimgui.dll" CopyToOutputDirectory="PreserveNewest" />
-        <Content Include="$(RepositoryRootDirectory)/deps/cimgui/osx-x64/cimgui.dylib" CopyToOutputDirectory="PreserveNewest"
-                 Link="lib%(Filename)%(Extension)" />
-        <Content Include="$(RepositoryRootDirectory)/deps/cimgui/linux-x64/cimgui.so" CopyToOutputDirectory="PreserveNewest"
-                 Link="lib%(Filename)%(Extension)" />
+        <Content Include="$(RepositoryRootDirectory)/deps/cimgui/osx/cimgui.dylib" CopyToOutputDirectory="PreserveNewest" Link="lib%(Filename)%(Extension)" />
+        <Content Include="$(RepositoryRootDirectory)/deps/cimgui/linux-x64/cimgui.so" CopyToOutputDirectory="PreserveNewest" Link="lib%(Filename)%(Extension)" />
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.7.0.1708" />
+      <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.1.303" />
     </ItemGroup>
 
 </Project>
diff --git a/src/ImGui.NET.SampleProgram.XNA/ImGuiRenderer.cs b/src/ImGui.NET.SampleProgram.XNA/ImGuiRenderer.cs
index 199b7539..04cd24b9 100644
--- a/src/ImGui.NET.SampleProgram.XNA/ImGuiRenderer.cs
+++ b/src/ImGui.NET.SampleProgram.XNA/ImGuiRenderer.cs
@@ -36,8 +36,9 @@ public class ImGuiRenderer
 
         // Input
         private int _scrollWheelValue;
-
-        private List<int> _keys = new List<int>();
+        private int _horizontalScrollWheelValue;
+        private readonly float WHEEL_DELTA = 120;
+        private Keys[] _allKeys = Enum.GetValues<Keys>();
 
         public ImGuiRenderer(Game game)
         {
@@ -139,39 +140,19 @@ public virtual void AfterLayout()
         #region Setup & Update
 
         /// <summary>
-        /// Maps ImGui keys to XNA keys. We use this later on to tell ImGui what keys were pressed
+        /// Setup key input event handler.
         /// </summary>
         protected virtual void SetupInput()
         {
             var io = ImGui.GetIO();
 
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Tab] = (int)Keys.Tab);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.LeftArrow] = (int)Keys.Left);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.RightArrow] = (int)Keys.Right);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.UpArrow] = (int)Keys.Up);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.DownArrow] = (int)Keys.Down);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.PageUp] = (int)Keys.PageUp);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.PageDown] = (int)Keys.PageDown);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Home] = (int)Keys.Home);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.End] = (int)Keys.End);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Delete] = (int)Keys.Delete);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Backspace] = (int)Keys.Back);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Enter] = (int)Keys.Enter);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Escape] = (int)Keys.Escape);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.A] = (int)Keys.A);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.C] = (int)Keys.C);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.V] = (int)Keys.V);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.X] = (int)Keys.X);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Y] = (int)Keys.Y);
-            _keys.Add(io.KeyMap[(int)ImGuiKey.Z] = (int)Keys.Z);
-
             // MonoGame-specific //////////////////////
             _game.Window.TextInput += (s, a) =>
             {
                 if (a.Character == '\t') return;
-
                 io.AddInputCharacter(a.Character);
             };
+
             ///////////////////////////////////////////
 
             // FNA-specific ///////////////////////////
@@ -179,11 +160,9 @@ protected virtual void SetupInput()
             //{
             //    if (c == '\t') return;
 
-            //    ImGui.AddInputCharacter(c);
+            //    ImGui.GetIO().AddInputCharacter(c);
             //};
             ///////////////////////////////////////////
-
-            ImGui.GetIO().Fonts.AddFontDefault();
         }
 
         /// <summary>
@@ -195,17 +174,9 @@ protected virtual Effect UpdateEffect(Texture2D texture)
 
             var io = ImGui.GetIO();
 
-            // MonoGame-specific //////////////////////
-            var offset = .5f;
-            ///////////////////////////////////////////
-
-            // FNA-specific ///////////////////////////
-            //var offset = 0f;
-            ///////////////////////////////////////////
-
             _effect.World = Matrix.Identity;
             _effect.View = Matrix.Identity;
-            _effect.Projection = Matrix.CreateOrthographicOffCenter(offset, io.DisplaySize.X + offset, io.DisplaySize.Y + offset, offset, -1f, 1f);
+            _effect.Projection = Matrix.CreateOrthographicOffCenter(0f, io.DisplaySize.X, io.DisplaySize.Y, 0f, -1f, 1f);
             _effect.TextureEnabled = true;
             _effect.Texture = texture;
             _effect.VertexColorEnabled = true;
@@ -218,33 +189,98 @@ protected virtual Effect UpdateEffect(Texture2D texture)
         /// </summary>
         protected virtual void UpdateInput()
         {
+            if (!_game.IsActive) return;
+            
             var io = ImGui.GetIO();
 
             var mouse = Mouse.GetState();
             var keyboard = Keyboard.GetState();
+            io.AddMousePosEvent(mouse.X, mouse.Y);
+            io.AddMouseButtonEvent(0, mouse.LeftButton == ButtonState.Pressed);
+            io.AddMouseButtonEvent(1, mouse.RightButton == ButtonState.Pressed);
+            io.AddMouseButtonEvent(2, mouse.MiddleButton == ButtonState.Pressed);
+            io.AddMouseButtonEvent(3, mouse.XButton1 == ButtonState.Pressed);
+            io.AddMouseButtonEvent(4, mouse.XButton2 == ButtonState.Pressed);
+
+            io.AddMouseWheelEvent(
+                (mouse.HorizontalScrollWheelValue - _horizontalScrollWheelValue) / WHEEL_DELTA,
+                (mouse.ScrollWheelValue - _scrollWheelValue) / WHEEL_DELTA);
+            _scrollWheelValue = mouse.ScrollWheelValue;
+            _horizontalScrollWheelValue = mouse.HorizontalScrollWheelValue;
 
-            for (int i = 0; i < _keys.Count; i++)
+            foreach (var key in _allKeys)
             {
-                io.KeysDown[_keys[i]] = keyboard.IsKeyDown((Keys)_keys[i]);
+                if (TryMapKeys(key, out ImGuiKey imguikey))
+                {
+                    io.AddKeyEvent(imguikey, keyboard.IsKeyDown(key));
+                }
             }
 
-            io.KeyShift = keyboard.IsKeyDown(Keys.LeftShift) || keyboard.IsKeyDown(Keys.RightShift);
-            io.KeyCtrl = keyboard.IsKeyDown(Keys.LeftControl) || keyboard.IsKeyDown(Keys.RightControl);
-            io.KeyAlt = keyboard.IsKeyDown(Keys.LeftAlt) || keyboard.IsKeyDown(Keys.RightAlt);
-            io.KeySuper = keyboard.IsKeyDown(Keys.LeftWindows) || keyboard.IsKeyDown(Keys.RightWindows);
-
             io.DisplaySize = new System.Numerics.Vector2(_graphicsDevice.PresentationParameters.BackBufferWidth, _graphicsDevice.PresentationParameters.BackBufferHeight);
             io.DisplayFramebufferScale = new System.Numerics.Vector2(1f, 1f);
+        }
 
-            io.MousePos = new System.Numerics.Vector2(mouse.X, mouse.Y);
+        private bool TryMapKeys(Keys key, out ImGuiKey imguikey)
+        {
+            //Special case not handed in the switch...
+            //If the actual key we put in is "None", return none and true. 
+            //otherwise, return none and false.
+            if (key == Keys.None)
+            {
+                imguikey = ImGuiKey.None;
+                return true;
+            }
 
-            io.MouseDown[0] = mouse.LeftButton == ButtonState.Pressed;
-            io.MouseDown[1] = mouse.RightButton == ButtonState.Pressed;
-            io.MouseDown[2] = mouse.MiddleButton == ButtonState.Pressed;
+            imguikey = key switch
+            {
+                Keys.Back => ImGuiKey.Backspace,
+                Keys.Tab => ImGuiKey.Tab,
+                Keys.Enter => ImGuiKey.Enter,
+                Keys.CapsLock => ImGuiKey.CapsLock,
+                Keys.Escape => ImGuiKey.Escape,
+                Keys.Space => ImGuiKey.Space,
+                Keys.PageUp => ImGuiKey.PageUp,
+                Keys.PageDown => ImGuiKey.PageDown,
+                Keys.End => ImGuiKey.End,
+                Keys.Home => ImGuiKey.Home,
+                Keys.Left => ImGuiKey.LeftArrow,
+                Keys.Right => ImGuiKey.RightArrow,
+                Keys.Up => ImGuiKey.UpArrow,
+                Keys.Down => ImGuiKey.DownArrow,
+                Keys.PrintScreen => ImGuiKey.PrintScreen,
+                Keys.Insert => ImGuiKey.Insert,
+                Keys.Delete => ImGuiKey.Delete,
+                >= Keys.D0 and <= Keys.D9 => ImGuiKey._0 + (key - Keys.D0),
+                >= Keys.A and <= Keys.Z => ImGuiKey.A + (key - Keys.A),
+                >= Keys.NumPad0 and <= Keys.NumPad9 => ImGuiKey.Keypad0 + (key - Keys.NumPad0),
+                Keys.Multiply => ImGuiKey.KeypadMultiply,
+                Keys.Add => ImGuiKey.KeypadAdd,
+                Keys.Subtract => ImGuiKey.KeypadSubtract,
+                Keys.Decimal => ImGuiKey.KeypadDecimal,
+                Keys.Divide => ImGuiKey.KeypadDivide,
+                >= Keys.F1 and <= Keys.F24 => ImGuiKey.F1 + (key - Keys.F1),
+                Keys.NumLock => ImGuiKey.NumLock,
+                Keys.Scroll => ImGuiKey.ScrollLock,
+                Keys.LeftShift => ImGuiKey.ModShift,
+                Keys.LeftControl => ImGuiKey.ModCtrl,
+                Keys.LeftAlt => ImGuiKey.ModAlt,
+                Keys.OemSemicolon => ImGuiKey.Semicolon,
+                Keys.OemPlus => ImGuiKey.Equal,
+                Keys.OemComma => ImGuiKey.Comma,
+                Keys.OemMinus => ImGuiKey.Minus,
+                Keys.OemPeriod => ImGuiKey.Period,
+                Keys.OemQuestion => ImGuiKey.Slash,
+                Keys.OemTilde => ImGuiKey.GraveAccent,
+                Keys.OemOpenBrackets => ImGuiKey.LeftBracket,
+                Keys.OemCloseBrackets => ImGuiKey.RightBracket,
+                Keys.OemPipe => ImGuiKey.Backslash,
+                Keys.OemQuotes => ImGuiKey.Apostrophe,
+                Keys.BrowserBack => ImGuiKey.AppBack,
+                Keys.BrowserForward => ImGuiKey.AppForward,
+                _ => ImGuiKey.None,
+            };
 
-            var scrollDelta = mouse.ScrollWheelValue - _scrollWheelValue;
-            io.MouseWheel = scrollDelta > 0 ? 1 : scrollDelta < 0 ? -1 : 0;
-            _scrollWheelValue = mouse.ScrollWheelValue;
+            return imguikey != ImGuiKey.None;
         }
 
         #endregion Setup & Update
@@ -259,6 +295,10 @@ private void RenderDrawData(ImDrawDataPtr drawData)
             // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers
             var lastViewport = _graphicsDevice.Viewport;
             var lastScissorBox = _graphicsDevice.ScissorRectangle;
+            var lastRasterizer = _graphicsDevice.RasterizerState;
+            var lastDepthStencil = _graphicsDevice.DepthStencilState;
+            var lastBlendFactor = _graphicsDevice.BlendFactor;
+            var lastBlendState = _graphicsDevice.BlendState;
 
             _graphicsDevice.BlendFactor = Color.White;
             _graphicsDevice.BlendState = BlendState.NonPremultiplied;
@@ -278,6 +318,10 @@ private void RenderDrawData(ImDrawDataPtr drawData)
             // Restore modified state
             _graphicsDevice.Viewport = lastViewport;
             _graphicsDevice.ScissorRectangle = lastScissorBox;
+            _graphicsDevice.RasterizerState = lastRasterizer;
+            _graphicsDevice.DepthStencilState = lastDepthStencil;
+            _graphicsDevice.BlendState = lastBlendState;
+            _graphicsDevice.BlendFactor = lastBlendFactor;
         }
 
         private unsafe void UpdateBuffers(ImDrawDataPtr drawData)
@@ -312,7 +356,7 @@ private unsafe void UpdateBuffers(ImDrawDataPtr drawData)
 
             for (int n = 0; n < drawData.CmdListsCount; n++)
             {
-                ImDrawListPtr cmdList = drawData.CmdListsRange[n];
+                ImDrawListPtr cmdList = drawData.CmdLists[n];
 
                 fixed (void* vtxDstPtr = &_vertexData[vtxOffset * DrawVertDeclaration.Size])
                 fixed (void* idxDstPtr = &_indexData[idxOffset * sizeof(ushort)])
@@ -340,12 +384,17 @@ private unsafe void RenderCommandLists(ImDrawDataPtr drawData)
 
             for (int n = 0; n < drawData.CmdListsCount; n++)
             {
-                ImDrawListPtr cmdList = drawData.CmdListsRange[n];
+                ImDrawListPtr cmdList = drawData.CmdLists[n];
 
                 for (int cmdi = 0; cmdi < cmdList.CmdBuffer.Size; cmdi++)
                 {
                     ImDrawCmdPtr drawCmd = cmdList.CmdBuffer[cmdi];
 
+                    if (drawCmd.ElemCount == 0) 
+                    {
+                        continue;
+                    }
+
                     if (!_loadedTextures.ContainsKey(drawCmd.TextureId))
                     {
                         throw new InvalidOperationException($"Could not find a texture with id '{drawCmd.TextureId}', please check your bindings");
@@ -367,22 +416,21 @@ private unsafe void RenderCommandLists(ImDrawDataPtr drawData)
 #pragma warning disable CS0618 // // FNA does not expose an alternative method.
                         _graphicsDevice.DrawIndexedPrimitives(
                             primitiveType: PrimitiveType.TriangleList,
-                            baseVertex: vtxOffset,
+                            baseVertex: (int)drawCmd.VtxOffset + vtxOffset,
                             minVertexIndex: 0,
                             numVertices: cmdList.VtxBuffer.Size,
-                            startIndex: idxOffset,
+                            startIndex: (int)drawCmd.IdxOffset + idxOffset,
                             primitiveCount: (int)drawCmd.ElemCount / 3
                         );
 #pragma warning restore CS0618
                     }
-
-                    idxOffset += (int)drawCmd.ElemCount;
                 }
 
                 vtxOffset += cmdList.VtxBuffer.Size;
+                idxOffset += cmdList.IdxBuffer.Size;
             }
         }
 
         #endregion Internals
     }
-}
\ No newline at end of file
+}
diff --git a/src/ImGui.NET.SampleProgram.XNA/SampleGame.cs b/src/ImGui.NET.SampleProgram.XNA/SampleGame.cs
index 0164d084..3eb4ba2e 100644
--- a/src/ImGui.NET.SampleProgram.XNA/SampleGame.cs
+++ b/src/ImGui.NET.SampleProgram.XNA/SampleGame.cs
@@ -82,7 +82,7 @@ protected virtual void ImGuiLayout()
             // Tip: if we don't call ImGui.Begin()/ImGui.End() the widgets appears in a window automatically called "Debug"
             {
                 ImGui.Text("Hello, world!");
-                ImGui.SliderFloat("float", ref f, 0.0f, 1.0f, string.Empty, 1f);
+                ImGui.SliderFloat("float", ref f, 0.0f, 1.0f, string.Empty);
                 ImGui.ColorEdit3("clear color", ref clear_color);
                 if (ImGui.Button("Test Window")) show_test_window = !show_test_window;
                 if (ImGui.Button("Another Window")) show_another_window = !show_another_window;
diff --git a/src/ImGui.NET.SampleProgram/ImGui.NET.SampleProgram.csproj b/src/ImGui.NET.SampleProgram/ImGui.NET.SampleProgram.csproj
index bb07cc00..2c538251 100644
--- a/src/ImGui.NET.SampleProgram/ImGui.NET.SampleProgram.csproj
+++ b/src/ImGui.NET.SampleProgram/ImGui.NET.SampleProgram.csproj
@@ -1,15 +1,17 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\ImGui.NET\ImGui.NET.csproj" />
-    <PackageReference Include="Veldrid" Version="4.3.3" />
-    <PackageReference Include="Veldrid.StartupUtilities" Version="4.3.3" />
+    <PackageReference Include="Veldrid" Version="4.9.0" />
+    <PackageReference Include="Veldrid.StartupUtilities" Version="4.9.0" />
+    <ProjectReference Include="..\ImPlot.NET\ImPlot.NET.csproj" />
+    <ProjectReference Include="..\TestDotNetStandardLib\TestDotNetStandardLib.csproj" />
   </ItemGroup>
 
   <ItemGroup>
@@ -25,7 +27,7 @@
 
   <ItemGroup>
     <Content Include="$(RepositoryRootDirectory)/deps/cimgui/win-x64/cimgui.dll" CopyToOutputDirectory="PreserveNewest" />
-    <Content Include="$(RepositoryRootDirectory)/deps/cimgui/osx-x64/cimgui.dylib" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="$(RepositoryRootDirectory)/deps/cimgui/osx/cimgui.dylib" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="$(RepositoryRootDirectory)/deps/cimgui/linux-x64/cimgui.so" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
diff --git a/src/ImGui.NET.SampleProgram/ImGuiController.cs b/src/ImGui.NET.SampleProgram/ImGuiController.cs
index 64d6ef9e..47ec3a31 100644
--- a/src/ImGui.NET.SampleProgram/ImGuiController.cs
+++ b/src/ImGui.NET.SampleProgram/ImGuiController.cs
@@ -59,16 +59,15 @@ public ImGuiController(GraphicsDevice gd, OutputDescription outputDescription, i
             _windowWidth = width;
             _windowHeight = height;
 
-            IntPtr context = ImGui.CreateContext();
-            ImGui.SetCurrentContext(context);
-
-            ImGui.GetIO().Fonts.AddFontDefault();
+            ImGui.CreateContext();
+            var io = ImGui.GetIO();
+            io.BackendFlags |= ImGuiBackendFlags.RendererHasVtxOffset;
+            io.ConfigFlags |= ImGuiConfigFlags.NavEnableKeyboard |
+                ImGuiConfigFlags.DockingEnable;
+            io.Fonts.Flags |= ImFontAtlasFlags.NoBakedLines;
 
             CreateDeviceResources(gd, outputDescription);
-            SetKeyMappings();
-
             SetPerFrameImGuiData(1f / 60f);
-
             ImGui.NewFrame();
             _frameBegun = true;
         }
@@ -99,8 +98,8 @@ public void CreateDeviceResources(GraphicsDevice gd, OutputDescription outputDes
 
             byte[] vertexShaderBytes = LoadEmbeddedShaderCode(gd.ResourceFactory, "imgui-vertex", ShaderStages.Vertex);
             byte[] fragmentShaderBytes = LoadEmbeddedShaderCode(gd.ResourceFactory, "imgui-frag", ShaderStages.Fragment);
-            _vertexShader = factory.CreateShader(new ShaderDescription(ShaderStages.Vertex, vertexShaderBytes, "VS"));
-            _fragmentShader = factory.CreateShader(new ShaderDescription(ShaderStages.Fragment, fragmentShaderBytes, "FS"));
+            _vertexShader = factory.CreateShader(new ShaderDescription(ShaderStages.Vertex, vertexShaderBytes, gd.BackendType == GraphicsBackend.Metal ? "VS" : "main"));
+            _fragmentShader = factory.CreateShader(new ShaderDescription(ShaderStages.Fragment, fragmentShaderBytes, gd.BackendType == GraphicsBackend.Metal ? "FS" : "main"));
 
             VertexLayoutDescription[] vertexLayouts = new VertexLayoutDescription[]
             {
@@ -123,7 +122,8 @@ public void CreateDeviceResources(GraphicsDevice gd, OutputDescription outputDes
                 PrimitiveTopology.TriangleList,
                 new ShaderSetDescription(vertexLayouts, new[] { _vertexShader, _fragmentShader }),
                 new ResourceLayout[] { _layout, _textureLayout },
-                outputDescription);
+                outputDescription,
+                ResourceBindingModel.Default);
             _pipeline = factory.CreateGraphicsPipeline(ref pd);
 
             _mainResourceSet = factory.CreateResourceSet(new ResourceSetDescription(_layout,
@@ -244,11 +244,11 @@ private byte[] GetEmbeddedResourceBytes(string resourceName)
         /// <summary>
         /// Recreates the device texture used to render text.
         /// </summary>
-        public unsafe void RecreateFontDeviceTexture(GraphicsDevice gd)
+        public void RecreateFontDeviceTexture(GraphicsDevice gd)
         {
             ImGuiIOPtr io = ImGui.GetIO();
             // Build
-            byte* pixels;
+            IntPtr pixels;
             int width, height, bytesPerPixel;
             io.Fonts.GetTexDataAsRGBA32(out pixels, out width, out height, out bytesPerPixel);
             // Store our identifier
@@ -264,7 +264,7 @@ public unsafe void RecreateFontDeviceTexture(GraphicsDevice gd)
             _fontTexture.Name = "ImGui.NET Font Texture";
             gd.UpdateTexture(
                 _fontTexture,
-                (IntPtr)pixels,
+                pixels,
                 (uint)(bytesPerPixel * width * height),
                 0,
                 0,
@@ -326,99 +326,91 @@ private void SetPerFrameImGuiData(float deltaSeconds)
             io.DeltaTime = deltaSeconds; // DeltaTime is in seconds.
         }
 
-        private void UpdateImGuiInput(InputSnapshot snapshot)
+        private bool TryMapKey(Key key, out ImGuiKey result)
         {
-            ImGuiIOPtr io = ImGui.GetIO();
-
-            Vector2 mousePosition = snapshot.MousePosition;
-
-            // Determine if any of the mouse buttons were pressed during this snapshot period, even if they are no longer held.
-            bool leftPressed = false;
-            bool middlePressed = false;
-            bool rightPressed = false;
-            foreach (MouseEvent me in snapshot.MouseEvents)
+            ImGuiKey KeyToImGuiKeyShortcut(Key keyToConvert, Key startKey1, ImGuiKey startKey2)
             {
-                if (me.Down)
-                {
-                    switch (me.MouseButton)
-                    {
-                        case MouseButton.Left:
-                            leftPressed = true;
-                            break;
-                        case MouseButton.Middle:
-                            middlePressed = true;
-                            break;
-                        case MouseButton.Right:
-                            rightPressed = true;
-                            break;
-                    }
-                }
+                int changeFromStart1 = (int)keyToConvert - (int)startKey1;
+                return startKey2 + changeFromStart1;
             }
 
-            io.MouseDown[0] = leftPressed || snapshot.IsMouseDown(MouseButton.Left);
-            io.MouseDown[1] = rightPressed || snapshot.IsMouseDown(MouseButton.Right);
-            io.MouseDown[2] = middlePressed || snapshot.IsMouseDown(MouseButton.Middle);
-            io.MousePos = mousePosition;
-            io.MouseWheel = snapshot.WheelDelta;
+            result = key switch
+            {
+                >= Key.F1 and <= Key.F24 => KeyToImGuiKeyShortcut(key, Key.F1, ImGuiKey.F1),
+                >= Key.Keypad0 and <= Key.Keypad9 => KeyToImGuiKeyShortcut(key, Key.Keypad0, ImGuiKey.Keypad0),
+                >= Key.A and <= Key.Z => KeyToImGuiKeyShortcut(key, Key.A, ImGuiKey.A),
+                >= Key.Number0 and <= Key.Number9 => KeyToImGuiKeyShortcut(key, Key.Number0, ImGuiKey._0),
+                Key.ShiftLeft or Key.ShiftRight => ImGuiKey.ModShift,
+                Key.ControlLeft or Key.ControlRight => ImGuiKey.ModCtrl,
+                Key.AltLeft or Key.AltRight => ImGuiKey.ModAlt,
+                Key.WinLeft or Key.WinRight => ImGuiKey.ModSuper,
+                Key.Menu => ImGuiKey.Menu,
+                Key.Up => ImGuiKey.UpArrow,
+                Key.Down => ImGuiKey.DownArrow,
+                Key.Left => ImGuiKey.LeftArrow,
+                Key.Right => ImGuiKey.RightArrow,
+                Key.Enter => ImGuiKey.Enter,
+                Key.Escape => ImGuiKey.Escape,
+                Key.Space => ImGuiKey.Space,
+                Key.Tab => ImGuiKey.Tab,
+                Key.BackSpace => ImGuiKey.Backspace,
+                Key.Insert => ImGuiKey.Insert,
+                Key.Delete => ImGuiKey.Delete,
+                Key.PageUp => ImGuiKey.PageUp,
+                Key.PageDown => ImGuiKey.PageDown,
+                Key.Home => ImGuiKey.Home,
+                Key.End => ImGuiKey.End,
+                Key.CapsLock => ImGuiKey.CapsLock,
+                Key.ScrollLock => ImGuiKey.ScrollLock,
+                Key.PrintScreen => ImGuiKey.PrintScreen,
+                Key.Pause => ImGuiKey.Pause,
+                Key.NumLock => ImGuiKey.NumLock,
+                Key.KeypadDivide => ImGuiKey.KeypadDivide,
+                Key.KeypadMultiply => ImGuiKey.KeypadMultiply,
+                Key.KeypadSubtract => ImGuiKey.KeypadSubtract,
+                Key.KeypadAdd => ImGuiKey.KeypadAdd,
+                Key.KeypadDecimal => ImGuiKey.KeypadDecimal,
+                Key.KeypadEnter => ImGuiKey.KeypadEnter,
+                Key.Tilde => ImGuiKey.GraveAccent,
+                Key.Minus => ImGuiKey.Minus,
+                Key.Plus => ImGuiKey.Equal,
+                Key.BracketLeft => ImGuiKey.LeftBracket,
+                Key.BracketRight => ImGuiKey.RightBracket,
+                Key.Semicolon => ImGuiKey.Semicolon,
+                Key.Quote => ImGuiKey.Apostrophe,
+                Key.Comma => ImGuiKey.Comma,
+                Key.Period => ImGuiKey.Period,
+                Key.Slash => ImGuiKey.Slash,
+                Key.BackSlash or Key.NonUSBackSlash => ImGuiKey.Backslash,
+                _ => ImGuiKey.None
+            };
+
+            return result != ImGuiKey.None;
+        }
 
-            IReadOnlyList<char> keyCharPresses = snapshot.KeyCharPresses;
-            for (int i = 0; i < keyCharPresses.Count; i++)
+        private void UpdateImGuiInput(InputSnapshot snapshot)
+        {
+            ImGuiIOPtr io = ImGui.GetIO();
+            io.AddMousePosEvent(snapshot.MousePosition.X, snapshot.MousePosition.Y);
+            io.AddMouseButtonEvent(0, snapshot.IsMouseDown(MouseButton.Left));
+            io.AddMouseButtonEvent(1, snapshot.IsMouseDown(MouseButton.Right));
+            io.AddMouseButtonEvent(2, snapshot.IsMouseDown(MouseButton.Middle));
+            io.AddMouseButtonEvent(3, snapshot.IsMouseDown(MouseButton.Button1));
+            io.AddMouseButtonEvent(4, snapshot.IsMouseDown(MouseButton.Button2));
+            io.AddMouseWheelEvent(0f, snapshot.WheelDelta);
+            for (int i = 0; i < snapshot.KeyCharPresses.Count; i++)
             {
-                char c = keyCharPresses[i];
-                io.AddInputCharacter(c);
+                io.AddInputCharacter(snapshot.KeyCharPresses[i]);
             }
 
-            IReadOnlyList<KeyEvent> keyEvents = snapshot.KeyEvents;
-            for (int i = 0; i < keyEvents.Count; i++)
+            for (int i = 0; i < snapshot.KeyEvents.Count; i++)
             {
-                KeyEvent keyEvent = keyEvents[i];
-                io.KeysDown[(int)keyEvent.Key] = keyEvent.Down;
-                if (keyEvent.Key == Key.ControlLeft)
-                {
-                    _controlDown = keyEvent.Down;
-                }
-                if (keyEvent.Key == Key.ShiftLeft)
-                {
-                    _shiftDown = keyEvent.Down;
-                }
-                if (keyEvent.Key == Key.AltLeft)
+                KeyEvent keyEvent = snapshot.KeyEvents[i];
+                if (TryMapKey(keyEvent.Key, out ImGuiKey imguikey))
                 {
-                    _altDown = keyEvent.Down;
-                }
-                if (keyEvent.Key == Key.WinLeft)
-                {
-                    _winKeyDown = keyEvent.Down;
+                    io.AddKeyEvent(imguikey, keyEvent.Down);
                 }
             }
-
-            io.KeyCtrl = _controlDown;
-            io.KeyAlt = _altDown;
-            io.KeyShift = _shiftDown;
-            io.KeySuper = _winKeyDown;
-        }
-
-        private static void SetKeyMappings()
-        {
-            ImGuiIOPtr io = ImGui.GetIO();
-            io.KeyMap[(int)ImGuiKey.Tab] = (int)Key.Tab;
-            io.KeyMap[(int)ImGuiKey.LeftArrow] = (int)Key.Left;
-            io.KeyMap[(int)ImGuiKey.RightArrow] = (int)Key.Right;
-            io.KeyMap[(int)ImGuiKey.UpArrow] = (int)Key.Up;
-            io.KeyMap[(int)ImGuiKey.DownArrow] = (int)Key.Down;
-            io.KeyMap[(int)ImGuiKey.PageUp] = (int)Key.PageUp;
-            io.KeyMap[(int)ImGuiKey.PageDown] = (int)Key.PageDown;
-            io.KeyMap[(int)ImGuiKey.Home] = (int)Key.Home;
-            io.KeyMap[(int)ImGuiKey.End] = (int)Key.End;
-            io.KeyMap[(int)ImGuiKey.Delete] = (int)Key.Delete;
-            io.KeyMap[(int)ImGuiKey.Backspace] = (int)Key.BackSpace;
-            io.KeyMap[(int)ImGuiKey.Enter] = (int)Key.Enter;
-            io.KeyMap[(int)ImGuiKey.Escape] = (int)Key.Escape;
-            io.KeyMap[(int)ImGuiKey.A] = (int)Key.A;
-            io.KeyMap[(int)ImGuiKey.C] = (int)Key.C;
-            io.KeyMap[(int)ImGuiKey.V] = (int)Key.V;
-            io.KeyMap[(int)ImGuiKey.X] = (int)Key.X;
-            io.KeyMap[(int)ImGuiKey.Y] = (int)Key.Y;
-            io.KeyMap[(int)ImGuiKey.Z] = (int)Key.Z;
         }
 
         private void RenderImDrawData(ImDrawDataPtr draw_data, GraphicsDevice gd, CommandList cl)
@@ -447,7 +439,7 @@ private void RenderImDrawData(ImDrawDataPtr draw_data, GraphicsDevice gd, Comman
 
             for (int i = 0; i < draw_data.CmdListsCount; i++)
             {
-                ImDrawListPtr cmd_list = draw_data.CmdListsRange[i];
+                ImDrawListPtr cmd_list = draw_data.CmdLists[i];
 
                 cl.UpdateBuffer(
                     _vertexBuffer,
@@ -489,7 +481,7 @@ private void RenderImDrawData(ImDrawDataPtr draw_data, GraphicsDevice gd, Comman
             int idx_offset = 0;
             for (int n = 0; n < draw_data.CmdListsCount; n++)
             {
-                ImDrawListPtr cmd_list = draw_data.CmdListsRange[n];
+                ImDrawListPtr cmd_list = draw_data.CmdLists[n];
                 for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++)
                 {
                     ImDrawCmdPtr pcmd = cmd_list.CmdBuffer[cmd_i];
@@ -518,12 +510,11 @@ private void RenderImDrawData(ImDrawDataPtr draw_data, GraphicsDevice gd, Comman
                             (uint)(pcmd.ClipRect.Z - pcmd.ClipRect.X),
                             (uint)(pcmd.ClipRect.W - pcmd.ClipRect.Y));
 
-                        cl.DrawIndexed(pcmd.ElemCount, 1, (uint)idx_offset, vtx_offset, 0);
+                        cl.DrawIndexed(pcmd.ElemCount, 1, pcmd.IdxOffset + (uint)idx_offset, (int)pcmd.VtxOffset + vtx_offset, 0);
                     }
-
-                    idx_offset += (int)pcmd.ElemCount;
                 }
                 vtx_offset += cmd_list.VtxBuffer.Size;
+                idx_offset += cmd_list.IdxBuffer.Size;
             }
         }
 
diff --git a/src/ImGui.NET.SampleProgram/MemoryEditor.cs b/src/ImGui.NET.SampleProgram/MemoryEditor.cs
index 8286d15b..3751216f 100644
--- a/src/ImGui.NET.SampleProgram/MemoryEditor.cs
+++ b/src/ImGui.NET.SampleProgram/MemoryEditor.cs
@@ -3,6 +3,8 @@
 using ImGuiNET;
 using System.Numerics;
 
+#if false
+
 namespace ImGuiNET
 {
     // C# port of ocornut's imgui_memory_editor.h - https://gist.github.com/ocornut/0673e37e54aff644298b
@@ -104,7 +106,7 @@ public unsafe void Draw(string title, byte[] mem_data, int mem_size, int base_di
                 float scroll_offset = ((DataEditingAddr / Rows) - (data_editing_addr_backup / Rows)) * line_height;
                 bool scroll_desired = (scroll_offset < 0.0f && DataEditingAddr < visible_start_addr + Rows * 2) || (scroll_offset > 0.0f && DataEditingAddr > visible_end_addr - Rows * 2);
                 if (scroll_desired)
-                    ImGuiNative.igSetScrollY(ImGuiNative.igGetScrollY() + scroll_offset);
+                    ImGuiNative.igSetScrollY_Float(ImGuiNative.igGetScrollY() + scroll_offset);
             }
 
             for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible items
@@ -143,7 +145,7 @@ public unsafe void Draw(string title, byte[] mem_data, int mem_size, int base_di
                         }
                         ImGui.PushItemWidth(ImGui.CalcTextSize("FF").X);
 
-                        var flags = ImGuiInputTextFlags.CharsHexadecimal | ImGuiInputTextFlags.EnterReturnsTrue | ImGuiInputTextFlags.AutoSelectAll | ImGuiInputTextFlags.NoHorizontalScroll | ImGuiInputTextFlags.AlwaysInsertMode | ImGuiInputTextFlags.CallbackAlways;
+                        var flags = ImGuiInputTextFlags.CharsHexadecimal | ImGuiInputTextFlags.EnterReturnsTrue | ImGuiInputTextFlags.AutoSelectAll | ImGuiInputTextFlags.NoHorizontalScroll | ImGuiInputTextFlags.CallbackAlways;
 
                         if (ImGui.InputText("##data", DataInput, 32, flags, callback, (IntPtr)(&cursor_pos)))
                             data_write = data_next = true;
@@ -274,4 +276,5 @@ public unsafe void Begin(int count, float items_height = -1.0f)
             }
         }
     }
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file
diff --git a/src/ImGui.NET.SampleProgram/Program.cs b/src/ImGui.NET.SampleProgram/Program.cs
index 466f8f8b..2f85865c 100644
--- a/src/ImGui.NET.SampleProgram/Program.cs
+++ b/src/ImGui.NET.SampleProgram/Program.cs
@@ -1,6 +1,10 @@
 using System;
+using System.Diagnostics;
 using System.Linq;
 using System.Numerics;
+using ImPlotNET;
+using System.Runtime.CompilerServices;
+using TestDotNetStandardLib;
 using Veldrid;
 using Veldrid.Sdl2;
 using Veldrid.StartupUtilities;
@@ -15,14 +19,14 @@ class Program
         private static GraphicsDevice _gd;
         private static CommandList _cl;
         private static ImGuiController _controller;
-        private static MemoryEditor _memoryEditor;
+        // private static MemoryEditor _memoryEditor;
 
         // UI state
         private static float _f = 0.0f;
         private static int _counter = 0;
         private static int _dragInt = 0;
         private static Vector3 _clearColor = new Vector3(0.45f, 0.55f, 0.6f);
-        private static bool _showDemoWindow = true;
+        private static bool _showImGuiDemoWindow = true;
         private static bool _showAnotherWindow = false;
         private static bool _showMemoryEditor = false;
         private static byte[] _memoryEditorData;
@@ -36,7 +40,7 @@ static void Main(string[] args)
             // Create window, GraphicsDevice, and all resources necessary for the demo.
             VeldridStartup.CreateWindowAndGraphicsDevice(
                 new WindowCreateInfo(50, 50, 1280, 720, WindowState.Normal, "ImGui.NET Sample Program"),
-                new GraphicsDeviceOptions(true, null, true),
+                new GraphicsDeviceOptions(true, null, true, ResourceBindingModel.Improved, true, true),
                 out _window,
                 out _gd);
             _window.Resized += () =>
@@ -46,16 +50,20 @@ static void Main(string[] args)
             };
             _cl = _gd.ResourceFactory.CreateCommandList();
             _controller = new ImGuiController(_gd, _gd.MainSwapchain.Framebuffer.OutputDescription, _window.Width, _window.Height);
-            _memoryEditor = new MemoryEditor();
+            // _memoryEditor = new MemoryEditor();
             Random random = new Random();
             _memoryEditorData = Enumerable.Range(0, 1024).Select(i => (byte)random.Next(255)).ToArray();
 
+            var stopwatch = Stopwatch.StartNew();
+            float deltaTime = 0f;
             // Main application loop
             while (_window.Exists)
             {
+                deltaTime = stopwatch.ElapsedTicks / (float)Stopwatch.Frequency;
+                stopwatch.Restart();
                 InputSnapshot snapshot = _window.PumpEvents();
                 if (!_window.Exists) { break; }
-                _controller.Update(1f / 60f, snapshot); // Feed the input events to our ImGui controller, which passes them through to ImGui.
+                _controller.Update(deltaTime, snapshot); // Feed the input events to our ImGui controller, which passes them through to ImGui.
 
                 SubmitUI();
 
@@ -81,15 +89,17 @@ private static unsafe void SubmitUI()
             // https://github.com/ocornut/imgui/blob/master/examples/example_win32_directx11/main.cpp#L172
 
             // 1. Show a simple window.
-            // Tip: if we don't call ImGui.BeginWindow()/ImGui.EndWindow() the widgets automatically appears in a window called "Debug".
+            // Tip: if we don't call ImGui.Begin(string) / ImGui.End() the widgets automatically appears in a window called "Debug".
             {
+                ImGui.Text("");
+                ImGui.Text(string.Empty);
                 ImGui.Text("Hello, world!");                                        // Display some text (you can use a format string too)
-                ImGui.SliderFloat("float", ref _f, 0, 1, _f.ToString("0.000"), 1);  // Edit 1 float using a slider from 0.0f to 1.0f    
+                ImGui.SliderFloat("float", ref _f, 0, 1, _f.ToString("0.000"));  // Edit 1 float using a slider from 0.0f to 1.0f    
                 //ImGui.ColorEdit3("clear color", ref _clearColor);                   // Edit 3 floats representing a color
 
                 ImGui.Text($"Mouse position: {ImGui.GetMousePos()}");
 
-                ImGui.Checkbox("Demo Window", ref _showDemoWindow);                 // Edit bools storing our windows open/close state
+                ImGui.Checkbox("ImGui Demo Window", ref _showImGuiDemoWindow);                 // Edit bools storing our windows open/close state
                 ImGui.Checkbox("Another Window", ref _showAnotherWindow);
                 ImGui.Checkbox("Memory Editor", ref _showMemoryEditor);
                 if (ImGui.Button("Button"))                                         // Buttons return true when clicked (NB: most widgets return true when edited/activated)
@@ -114,14 +124,14 @@ private static unsafe void SubmitUI()
             }
 
             // 3. Show the ImGui demo window. Most of the sample code is in ImGui.ShowDemoWindow(). Read its code to learn more about Dear ImGui!
-            if (_showDemoWindow)
+            if (_showImGuiDemoWindow)
             {
                 // Normally user code doesn't need/want to call this because positions are saved in .ini file anyway.
                 // Here we just want to make the demo initial state a bit more friendly!
                 ImGui.SetNextWindowPos(new Vector2(650, 20), ImGuiCond.FirstUseEver);
-                ImGui.ShowDemoWindow(ref _showDemoWindow);
+                ImGui.ShowDemoWindow(ref _showImGuiDemoWindow);
             }
-
+            
             if (ImGui.TreeNode("Tabs"))
             {
                 if (ImGui.TreeNode("Basic"))
@@ -159,9 +169,9 @@ private static unsafe void SubmitUI()
                     if ((s_tab_bar_flags & (uint)ImGuiTabBarFlags.FittingPolicyMask) == 0)
                         s_tab_bar_flags |= (uint)ImGuiTabBarFlags.FittingPolicyDefault;
                     if (ImGui.CheckboxFlags("ImGuiTabBarFlags_FittingPolicyResizeDown", ref s_tab_bar_flags, (uint)ImGuiTabBarFlags.FittingPolicyResizeDown))
-                s_tab_bar_flags &= ~((uint)ImGuiTabBarFlags.FittingPolicyMask ^ (uint)ImGuiTabBarFlags.FittingPolicyResizeDown);
+                        s_tab_bar_flags &= ~((uint)ImGuiTabBarFlags.FittingPolicyMask ^ (uint)ImGuiTabBarFlags.FittingPolicyResizeDown);
                     if (ImGui.CheckboxFlags("ImGuiTabBarFlags_FittingPolicyScroll", ref s_tab_bar_flags, (uint)ImGuiTabBarFlags.FittingPolicyScroll))
-                s_tab_bar_flags &= ~((uint)ImGuiTabBarFlags.FittingPolicyMask ^ (uint)ImGuiTabBarFlags.FittingPolicyScroll);
+                        s_tab_bar_flags &= ~((uint)ImGuiTabBarFlags.FittingPolicyMask ^ (uint)ImGuiTabBarFlags.FittingPolicyScroll);
 
                     // Tab Bar
                     string[] names = { "Artichoke", "Beetroot", "Celery", "Daikon" };
@@ -196,8 +206,31 @@ private static unsafe void SubmitUI()
 
             if (_showMemoryEditor)
             {
-                _memoryEditor.Draw("Memory Editor", _memoryEditorData, _memoryEditorData.Length);
+                ImGui.Text("Memory editor currently supported.");
+                // _memoryEditor.Draw("Memory Editor", _memoryEditorData, _memoryEditorData.Length);
             }
+            
+            // ReadOnlySpan<char> and .NET Standard 2.0 tests
+            TestStringParameterOnDotNetStandard.Text(); // String overloads should always be available.
+            
+            // On .NET Standard 2.1 or greater, you can use ReadOnlySpan<char> instead of string to prevent allocations.
+            long allocBytesStringStart = GC.GetAllocatedBytesForCurrentThread();
+            ImGui.Text($"Hello, world {Random.Shared.Next(100)}!");
+            long allocBytesStringEnd = GC.GetAllocatedBytesForCurrentThread() - allocBytesStringStart;
+            Console.WriteLine("GC (string): " + allocBytesStringEnd);
+                
+            long allocBytesSpanStart = GC.GetAllocatedBytesForCurrentThread();
+            ImGui.Text($"Hello, world {Random.Shared.Next(100)}!".AsSpan()); // Note that this call will STILL allocate memory due to string interpolation, but you can prevent that from happening by using an InterpolatedStringHandler.
+            long allocBytesSpanEnd = GC.GetAllocatedBytesForCurrentThread() - allocBytesSpanStart;
+            Console.WriteLine("GC (span): " + allocBytesSpanEnd);
+            
+            ImGui.Text("Empty span:");
+            ImGui.SameLine();
+            ImGui.GetWindowDrawList().AddText(ImGui.GetCursorScreenPos(), uint.MaxValue, ReadOnlySpan<char>.Empty);
+            ImGui.NewLine();
+            ImGui.GetWindowDrawList().AddText(ImGui.GetCursorScreenPos(), uint.MaxValue, $"{ImGui.CalcTextSize("h")}");
+            ImGui.NewLine();
+            ImGui.TextUnformatted("TextUnformatted now passes end ptr but isn't cut off");
         }
     }
 }
diff --git a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.glsl b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.glsl
index 2d1c1d78..f94fa485 100644
--- a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.glsl
+++ b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.glsl
@@ -13,4 +13,4 @@ layout (location = 0) out vec4 outputColor;
 void main()
 {
     outputColor = color * texture(sampler2D(FontTexture, FontSampler), texCoord);
-}
+}
\ No newline at end of file
diff --git a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.spv b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.spv
index c8d71cc6..5d3d96f3 100644
Binary files a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.spv and b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-frag.spv differ
diff --git a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.glsl b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.glsl
index 6fdab3f9..6249a36d 100644
--- a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.glsl
+++ b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.glsl
@@ -3,27 +3,26 @@
 #extension GL_ARB_separate_shader_objects : enable
 #extension GL_ARB_shading_language_420pack : enable
 
-layout (location = 0) in vec2 vsin_position;
-layout (location = 1) in vec2 vsin_texCoord;
-layout (location = 2) in vec4 vsin_color;
+layout (location = 0) in vec2 in_position;
+layout (location = 1) in vec2 in_texCoord;
+layout (location = 2) in vec4 in_color;
 
-layout (binding = 0) uniform Projection
+layout (binding = 0) uniform ProjectionMatrixBuffer
 {
-    mat4 projection;
+    mat4 projection_matrix;
 };
 
-layout (location = 0) out vec4 vsout_color;
-layout (location = 1) out vec2 vsout_texCoord;
+layout (location = 0) out vec4 color;
+layout (location = 1) out vec2 texCoord;
 
-out gl_PerVertex 
+out gl_PerVertex
 {
     vec4 gl_Position;
 };
 
 void main() 
 {
-    gl_Position = projection * vec4(vsin_position, 0, 1);
-    vsout_color = vsin_color;
-    vsout_texCoord = vsin_texCoord;
-    gl_Position.y = -gl_Position.y;
+    gl_Position = projection_matrix * vec4(in_position, 0, 1);
+    color = in_color;
+    texCoord = in_texCoord;
 }
diff --git a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.spv b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.spv
index 795cd0e7..b40ec8ca 100644
Binary files a/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.spv and b/src/ImGui.NET.SampleProgram/Shaders/SPIR-V/imgui-vertex.spv differ
diff --git a/src/ImGui.NET.sln b/src/ImGui.NET.sln
index e3857dcf..ed15103c 100644
--- a/src/ImGui.NET.sln
+++ b/src/ImGui.NET.sln
@@ -10,6 +10,14 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ImGui.NET.SampleProgram.XNA
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeGenerator", "CodeGenerator\CodeGenerator.csproj", "{62A4CFE3-C5F5-45F5-AD18-3F7E6739BD09}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImPlot.NET", "ImPlot.NET\ImPlot.NET.csproj", "{817A9820-E750-43AB-B89E-FD51E58ACBF4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImNodes.NET", "ImNodes.NET\ImNodes.NET.csproj", "{2786BF48-AE57-44EE-9E28-401AE88E972D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImGuizmo.NET", "ImGuizmo.NET\ImGuizmo.NET.csproj", "{760568AB-DCC9-443E-ADFA-2B06B2E2B421}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestDotNetStandardLib", "TestDotNetStandardLib\TestDotNetStandardLib.csproj", "{867D8763-15A2-40E4-AAFD-43B77AC52154}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -68,6 +76,54 @@ Global
 		{62A4CFE3-C5F5-45F5-AD18-3F7E6739BD09}.Release|x64.Build.0 = Release|Any CPU
 		{62A4CFE3-C5F5-45F5-AD18-3F7E6739BD09}.Release|x86.ActiveCfg = Release|Any CPU
 		{62A4CFE3-C5F5-45F5-AD18-3F7E6739BD09}.Release|x86.Build.0 = Release|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Debug|x64.Build.0 = Debug|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Debug|x86.Build.0 = Debug|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Release|x64.ActiveCfg = Release|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Release|x64.Build.0 = Release|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Release|x86.ActiveCfg = Release|Any CPU
+		{817A9820-E750-43AB-B89E-FD51E58ACBF4}.Release|x86.Build.0 = Release|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Debug|x64.Build.0 = Debug|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Debug|x86.Build.0 = Debug|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Release|x64.ActiveCfg = Release|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Release|x64.Build.0 = Release|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Release|x86.ActiveCfg = Release|Any CPU
+		{2786BF48-AE57-44EE-9E28-401AE88E972D}.Release|x86.Build.0 = Release|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Debug|x64.Build.0 = Debug|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Debug|x86.Build.0 = Debug|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Release|Any CPU.Build.0 = Release|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Release|x64.ActiveCfg = Release|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Release|x64.Build.0 = Release|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Release|x86.ActiveCfg = Release|Any CPU
+		{760568AB-DCC9-443E-ADFA-2B06B2E2B421}.Release|x86.Build.0 = Release|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Debug|x64.Build.0 = Debug|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Debug|x86.Build.0 = Debug|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Release|Any CPU.Build.0 = Release|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Release|x64.ActiveCfg = Release|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Release|x64.Build.0 = Release|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Release|x86.ActiveCfg = Release|Any CPU
+		{867D8763-15A2-40E4-AAFD-43B77AC52154}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/src/ImGui.NET/Delegates.cs b/src/ImGui.NET/Delegates.cs
new file mode 100644
index 00000000..4075f150
--- /dev/null
+++ b/src/ImGui.NET/Delegates.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Numerics;
+
+namespace ImGuiNET
+{
+    public delegate void Platform_CreateWindow(ImGuiViewportPtr vp);                    // Create a new platform window for the given viewport
+    public delegate void Platform_DestroyWindow(ImGuiViewportPtr vp);
+    public delegate void Platform_ShowWindow(ImGuiViewportPtr vp);                      // Newly created windows are initially hidden so SetWindowPos/Size/Title can be called on them first
+    public delegate void Platform_SetWindowPos(ImGuiViewportPtr vp, Vector2 pos);
+    public unsafe delegate void Platform_GetWindowPos(ImGuiViewportPtr vp, Vector2* outPos);
+    public delegate void Platform_SetWindowSize(ImGuiViewportPtr vp, Vector2 size);
+    public unsafe delegate void Platform_GetWindowSize(ImGuiViewportPtr vp, Vector2* outSize);
+    public delegate void Platform_SetWindowFocus(ImGuiViewportPtr vp);                  // Move window to front and set input focus
+    public delegate byte Platform_GetWindowFocus(ImGuiViewportPtr vp);
+    public delegate byte Platform_GetWindowMinimized(ImGuiViewportPtr vp);
+    public delegate void Platform_SetWindowTitle(ImGuiViewportPtr vp, IntPtr title);
+}
diff --git a/src/ImGui.NET/Generated/CustomRect.gen.cs b/src/ImGui.NET/Generated/CustomRect.gen.cs
deleted file mode 100644
index c12a7278..00000000
--- a/src/ImGui.NET/Generated/CustomRect.gen.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Text;
-
-namespace ImGuiNET
-{
-    public unsafe partial struct CustomRect
-    {
-        public uint ID;
-        public ushort Width;
-        public ushort Height;
-        public ushort X;
-        public ushort Y;
-        public float GlyphAdvanceX;
-        public Vector2 GlyphOffset;
-        public ImFont* Font;
-    }
-    public unsafe partial struct CustomRectPtr
-    {
-        public CustomRect* NativePtr { get; }
-        public CustomRectPtr(CustomRect* nativePtr) => NativePtr = nativePtr;
-        public CustomRectPtr(IntPtr nativePtr) => NativePtr = (CustomRect*)nativePtr;
-        public static implicit operator CustomRectPtr(CustomRect* nativePtr) => new CustomRectPtr(nativePtr);
-        public static implicit operator CustomRect* (CustomRectPtr wrappedPtr) => wrappedPtr.NativePtr;
-        public static implicit operator CustomRectPtr(IntPtr nativePtr) => new CustomRectPtr(nativePtr);
-        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
-        public ref ushort Width => ref Unsafe.AsRef<ushort>(&NativePtr->Width);
-        public ref ushort Height => ref Unsafe.AsRef<ushort>(&NativePtr->Height);
-        public ref ushort X => ref Unsafe.AsRef<ushort>(&NativePtr->X);
-        public ref ushort Y => ref Unsafe.AsRef<ushort>(&NativePtr->Y);
-        public ref float GlyphAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphAdvanceX);
-        public ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphOffset);
-        public ImFontPtr Font => new ImFontPtr(NativePtr->Font);
-        public bool IsPacked()
-        {
-            byte ret = ImGuiNative.CustomRect_IsPacked(NativePtr);
-            return ret != 0;
-        }
-    }
-}
diff --git a/src/ImGui.NET/Generated/ImColor.gen.cs b/src/ImGui.NET/Generated/ImColor.gen.cs
index 2f107959..009ed060 100644
--- a/src/ImGui.NET/Generated/ImColor.gen.cs
+++ b/src/ImGui.NET/Generated/ImColor.gen.cs
@@ -18,25 +18,31 @@ public unsafe partial struct ImColorPtr
         public static implicit operator ImColor* (ImColorPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImColorPtr(IntPtr nativePtr) => new ImColorPtr(nativePtr);
         public ref Vector4 Value => ref Unsafe.AsRef<Vector4>(&NativePtr->Value);
+        public void Destroy()
+        {
+            ImGuiNative.ImColor_destroy((ImColor*)(NativePtr));
+        }
         public ImColor HSV(float h, float s, float v)
         {
+            ImColor __retval;
             float a = 1.0f;
-            ImColor ret = ImGuiNative.ImColor_HSV(NativePtr, h, s, v, a);
-            return ret;
+            ImGuiNative.ImColor_HSV(&__retval, h, s, v, a);
+            return __retval;
         }
         public ImColor HSV(float h, float s, float v, float a)
         {
-            ImColor ret = ImGuiNative.ImColor_HSV(NativePtr, h, s, v, a);
-            return ret;
+            ImColor __retval;
+            ImGuiNative.ImColor_HSV(&__retval, h, s, v, a);
+            return __retval;
         }
         public void SetHSV(float h, float s, float v)
         {
             float a = 1.0f;
-            ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
+            ImGuiNative.ImColor_SetHSV((ImColor*)(NativePtr), h, s, v, a);
         }
         public void SetHSV(float h, float s, float v, float a)
         {
-            ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
+            ImGuiNative.ImColor_SetHSV((ImColor*)(NativePtr), h, s, v, a);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImDrawChannel.gen.cs b/src/ImGui.NET/Generated/ImDrawChannel.gen.cs
index 7b08e1a4..850df76d 100644
--- a/src/ImGui.NET/Generated/ImDrawChannel.gen.cs
+++ b/src/ImGui.NET/Generated/ImDrawChannel.gen.cs
@@ -7,8 +7,8 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImDrawChannel
     {
-        public ImVector CmdBuffer;
-        public ImVector IdxBuffer;
+        public ImVector _CmdBuffer;
+        public ImVector _IdxBuffer;
     }
     public unsafe partial struct ImDrawChannelPtr
     {
@@ -18,7 +18,7 @@ public unsafe partial struct ImDrawChannelPtr
         public static implicit operator ImDrawChannelPtr(ImDrawChannel* nativePtr) => new ImDrawChannelPtr(nativePtr);
         public static implicit operator ImDrawChannel* (ImDrawChannelPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImDrawChannelPtr(IntPtr nativePtr) => new ImDrawChannelPtr(nativePtr);
-        public ImPtrVector<ImDrawCmdPtr> CmdBuffer => new ImPtrVector<ImDrawCmdPtr>(NativePtr->CmdBuffer, Unsafe.SizeOf<ImDrawCmd>());
-        public ImVector<ushort> IdxBuffer => new ImVector<ushort>(NativePtr->IdxBuffer);
+        public ImPtrVector<ImDrawCmdPtr> _CmdBuffer => new ImPtrVector<ImDrawCmdPtr>(NativePtr->_CmdBuffer, Unsafe.SizeOf<ImDrawCmd>());
+        public ImVector<ushort> _IdxBuffer => new ImVector<ushort>(NativePtr->_IdxBuffer);
     }
 }
diff --git a/src/ImGui.NET/Generated/ImDrawCmd.gen.cs b/src/ImGui.NET/Generated/ImDrawCmd.gen.cs
index 9f0dd14c..1b24aeef 100644
--- a/src/ImGui.NET/Generated/ImDrawCmd.gen.cs
+++ b/src/ImGui.NET/Generated/ImDrawCmd.gen.cs
@@ -7,11 +7,15 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImDrawCmd
     {
-        public uint ElemCount;
         public Vector4 ClipRect;
         public IntPtr TextureId;
+        public uint VtxOffset;
+        public uint IdxOffset;
+        public uint ElemCount;
         public IntPtr UserCallback;
         public void* UserCallbackData;
+        public int UserCallbackDataSize;
+        public int UserCallbackDataOffset;
     }
     public unsafe partial struct ImDrawCmdPtr
     {
@@ -21,10 +25,23 @@ public unsafe partial struct ImDrawCmdPtr
         public static implicit operator ImDrawCmdPtr(ImDrawCmd* nativePtr) => new ImDrawCmdPtr(nativePtr);
         public static implicit operator ImDrawCmd* (ImDrawCmdPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImDrawCmdPtr(IntPtr nativePtr) => new ImDrawCmdPtr(nativePtr);
-        public ref uint ElemCount => ref Unsafe.AsRef<uint>(&NativePtr->ElemCount);
         public ref Vector4 ClipRect => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRect);
         public ref IntPtr TextureId => ref Unsafe.AsRef<IntPtr>(&NativePtr->TextureId);
+        public ref uint VtxOffset => ref Unsafe.AsRef<uint>(&NativePtr->VtxOffset);
+        public ref uint IdxOffset => ref Unsafe.AsRef<uint>(&NativePtr->IdxOffset);
+        public ref uint ElemCount => ref Unsafe.AsRef<uint>(&NativePtr->ElemCount);
         public ref IntPtr UserCallback => ref Unsafe.AsRef<IntPtr>(&NativePtr->UserCallback);
         public IntPtr UserCallbackData { get => (IntPtr)NativePtr->UserCallbackData; set => NativePtr->UserCallbackData = (void*)value; }
+        public ref int UserCallbackDataSize => ref Unsafe.AsRef<int>(&NativePtr->UserCallbackDataSize);
+        public ref int UserCallbackDataOffset => ref Unsafe.AsRef<int>(&NativePtr->UserCallbackDataOffset);
+        public void Destroy()
+        {
+            ImGuiNative.ImDrawCmd_destroy((ImDrawCmd*)(NativePtr));
+        }
+        public IntPtr GetTexID()
+        {
+            IntPtr ret = ImGuiNative.ImDrawCmd_GetTexID((ImDrawCmd*)(NativePtr));
+            return ret;
+        }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImDrawCmdHeader.gen.cs b/src/ImGui.NET/Generated/ImDrawCmdHeader.gen.cs
new file mode 100644
index 00000000..2d1c053d
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImDrawCmdHeader.gen.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImDrawCmdHeader
+    {
+        public Vector4 ClipRect;
+        public IntPtr TextureId;
+        public uint VtxOffset;
+    }
+    public unsafe partial struct ImDrawCmdHeaderPtr
+    {
+        public ImDrawCmdHeader* NativePtr { get; }
+        public ImDrawCmdHeaderPtr(ImDrawCmdHeader* nativePtr) => NativePtr = nativePtr;
+        public ImDrawCmdHeaderPtr(IntPtr nativePtr) => NativePtr = (ImDrawCmdHeader*)nativePtr;
+        public static implicit operator ImDrawCmdHeaderPtr(ImDrawCmdHeader* nativePtr) => new ImDrawCmdHeaderPtr(nativePtr);
+        public static implicit operator ImDrawCmdHeader* (ImDrawCmdHeaderPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImDrawCmdHeaderPtr(IntPtr nativePtr) => new ImDrawCmdHeaderPtr(nativePtr);
+        public ref Vector4 ClipRect => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRect);
+        public ref IntPtr TextureId => ref Unsafe.AsRef<IntPtr>(&NativePtr->TextureId);
+        public ref uint VtxOffset => ref Unsafe.AsRef<uint>(&NativePtr->VtxOffset);
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImDrawCornerFlags.gen.cs b/src/ImGui.NET/Generated/ImDrawCornerFlags.gen.cs
deleted file mode 100644
index 68953f84..00000000
--- a/src/ImGui.NET/Generated/ImDrawCornerFlags.gen.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-namespace ImGuiNET
-{
-    [System.Flags]
-    public enum ImDrawCornerFlags
-    {
-        TopLeft = 1 << 0,
-        TopRight = 1 << 1,
-        BotLeft = 1 << 2,
-        BotRight = 1 << 3,
-        Top = TopLeft | TopRight,
-        Bot = BotLeft | BotRight,
-        Left = TopLeft | BotLeft,
-        Right = TopRight | BotRight,
-        All = 0xF,
-    }
-}
diff --git a/src/ImGui.NET/Generated/ImDrawData.gen.cs b/src/ImGui.NET/Generated/ImDrawData.gen.cs
index 2275daf4..4ea932eb 100644
--- a/src/ImGui.NET/Generated/ImDrawData.gen.cs
+++ b/src/ImGui.NET/Generated/ImDrawData.gen.cs
@@ -8,12 +8,14 @@ namespace ImGuiNET
     public unsafe partial struct ImDrawData
     {
         public byte Valid;
-        public ImDrawList** CmdLists;
         public int CmdListsCount;
         public int TotalIdxCount;
         public int TotalVtxCount;
+        public ImVector CmdLists;
         public Vector2 DisplayPos;
         public Vector2 DisplaySize;
+        public Vector2 FramebufferScale;
+        public ImGuiViewport* OwnerViewport;
     }
     public unsafe partial struct ImDrawDataPtr
     {
@@ -24,23 +26,34 @@ public unsafe partial struct ImDrawDataPtr
         public static implicit operator ImDrawData* (ImDrawDataPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImDrawDataPtr(IntPtr nativePtr) => new ImDrawDataPtr(nativePtr);
         public ref bool Valid => ref Unsafe.AsRef<bool>(&NativePtr->Valid);
-        public IntPtr CmdLists { get => (IntPtr)NativePtr->CmdLists; set => NativePtr->CmdLists = (ImDrawList**)value; }
         public ref int CmdListsCount => ref Unsafe.AsRef<int>(&NativePtr->CmdListsCount);
         public ref int TotalIdxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalIdxCount);
         public ref int TotalVtxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalVtxCount);
+        public ImVector<ImDrawListPtr> CmdLists => new ImVector<ImDrawListPtr>(NativePtr->CmdLists);
         public ref Vector2 DisplayPos => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayPos);
         public ref Vector2 DisplaySize => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySize);
+        public ref Vector2 FramebufferScale => ref Unsafe.AsRef<Vector2>(&NativePtr->FramebufferScale);
+        public ImGuiViewportPtr OwnerViewport => new ImGuiViewportPtr(NativePtr->OwnerViewport);
+        public void AddDrawList(ImDrawListPtr draw_list)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            ImGuiNative.ImDrawData_AddDrawList((ImDrawData*)(NativePtr), native_draw_list);
+        }
         public void Clear()
         {
-            ImGuiNative.ImDrawData_Clear(NativePtr);
+            ImGuiNative.ImDrawData_Clear((ImDrawData*)(NativePtr));
         }
         public void DeIndexAllBuffers()
         {
-            ImGuiNative.ImDrawData_DeIndexAllBuffers(NativePtr);
+            ImGuiNative.ImDrawData_DeIndexAllBuffers((ImDrawData*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImDrawData_destroy((ImDrawData*)(NativePtr));
         }
-        public void ScaleClipRects(Vector2 sc)
+        public void ScaleClipRects(Vector2 fb_scale)
         {
-            ImGuiNative.ImDrawData_ScaleClipRects(NativePtr, sc);
+            ImGuiNative.ImDrawData_ScaleClipRects((ImDrawData*)(NativePtr), fb_scale);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImDrawFlags.gen.cs b/src/ImGui.NET/Generated/ImDrawFlags.gen.cs
new file mode 100644
index 00000000..60ae459a
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImDrawFlags.gen.cs
@@ -0,0 +1,21 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImDrawFlags
+    {
+        None = 0,
+        Closed = 1,
+        RoundCornersTopLeft = 16,
+        RoundCornersTopRight = 32,
+        RoundCornersBottomLeft = 64,
+        RoundCornersBottomRight = 128,
+        RoundCornersNone = 256,
+        RoundCornersTop = 48,
+        RoundCornersBottom = 192,
+        RoundCornersLeft = 80,
+        RoundCornersRight = 160,
+        RoundCornersAll = 240,
+        RoundCornersDefault = 240,
+        RoundCornersMask = 496,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImDrawList.gen.cs b/src/ImGui.NET/Generated/ImDrawList.gen.cs
index 7909fc80..fd7ad7d7 100644
--- a/src/ImGui.NET/Generated/ImDrawList.gen.cs
+++ b/src/ImGui.NET/Generated/ImDrawList.gen.cs
@@ -11,17 +11,18 @@ public unsafe partial struct ImDrawList
         public ImVector IdxBuffer;
         public ImVector VtxBuffer;
         public ImDrawListFlags Flags;
-        public IntPtr _Data;
-        public byte* _OwnerName;
         public uint _VtxCurrentIdx;
+        public IntPtr _Data;
         public ImDrawVert* _VtxWritePtr;
         public ushort* _IdxWritePtr;
+        public ImVector _Path;
+        public ImDrawCmdHeader _CmdHeader;
+        public ImDrawListSplitter _Splitter;
         public ImVector _ClipRectStack;
         public ImVector _TextureIdStack;
-        public ImVector _Path;
-        public int _ChannelsCurrent;
-        public int _ChannelsCount;
-        public ImVector _Channels;
+        public ImVector _CallbacksDataBuf;
+        public float _FringeScale;
+        public byte* _OwnerName;
     }
     public unsafe partial struct ImDrawListPtr
     {
@@ -35,380 +36,719 @@ public unsafe partial struct ImDrawListPtr
         public ImVector<ushort> IdxBuffer => new ImVector<ushort>(NativePtr->IdxBuffer);
         public ImPtrVector<ImDrawVertPtr> VtxBuffer => new ImPtrVector<ImDrawVertPtr>(NativePtr->VtxBuffer, Unsafe.SizeOf<ImDrawVert>());
         public ref ImDrawListFlags Flags => ref Unsafe.AsRef<ImDrawListFlags>(&NativePtr->Flags);
-        public ref IntPtr _Data => ref Unsafe.AsRef<IntPtr>(&NativePtr->_Data);
-        public NullTerminatedString _OwnerName => new NullTerminatedString(NativePtr->_OwnerName);
         public ref uint _VtxCurrentIdx => ref Unsafe.AsRef<uint>(&NativePtr->_VtxCurrentIdx);
+        public ref IntPtr _Data => ref Unsafe.AsRef<IntPtr>(&NativePtr->_Data);
         public ImDrawVertPtr _VtxWritePtr => new ImDrawVertPtr(NativePtr->_VtxWritePtr);
         public IntPtr _IdxWritePtr { get => (IntPtr)NativePtr->_IdxWritePtr; set => NativePtr->_IdxWritePtr = (ushort*)value; }
+        public ImVector<Vector2> _Path => new ImVector<Vector2>(NativePtr->_Path);
+        public ref ImDrawCmdHeader _CmdHeader => ref Unsafe.AsRef<ImDrawCmdHeader>(&NativePtr->_CmdHeader);
+        public ref ImDrawListSplitter _Splitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->_Splitter);
         public ImVector<Vector4> _ClipRectStack => new ImVector<Vector4>(NativePtr->_ClipRectStack);
         public ImVector<IntPtr> _TextureIdStack => new ImVector<IntPtr>(NativePtr->_TextureIdStack);
-        public ImVector<Vector2> _Path => new ImVector<Vector2>(NativePtr->_Path);
-        public ref int _ChannelsCurrent => ref Unsafe.AsRef<int>(&NativePtr->_ChannelsCurrent);
-        public ref int _ChannelsCount => ref Unsafe.AsRef<int>(&NativePtr->_ChannelsCount);
-        public ImPtrVector<ImDrawChannelPtr> _Channels => new ImPtrVector<ImDrawChannelPtr>(NativePtr->_Channels, Unsafe.SizeOf<ImDrawChannel>());
-        public void AddBezierCurve(Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness)
+        public ImVector<byte> _CallbacksDataBuf => new ImVector<byte>(NativePtr->_CallbacksDataBuf);
+        public ref float _FringeScale => ref Unsafe.AsRef<float>(&NativePtr->_FringeScale);
+        public NullTerminatedString _OwnerName => new NullTerminatedString(NativePtr->_OwnerName);
+        public int _CalcCircleAutoSegmentCount(float radius)
+        {
+            int ret = ImGuiNative.ImDrawList__CalcCircleAutoSegmentCount((ImDrawList*)(NativePtr), radius);
+            return ret;
+        }
+        public void _ClearFreeMemory()
+        {
+            ImGuiNative.ImDrawList__ClearFreeMemory((ImDrawList*)(NativePtr));
+        }
+        public void _OnChangedClipRect()
+        {
+            ImGuiNative.ImDrawList__OnChangedClipRect((ImDrawList*)(NativePtr));
+        }
+        public void _OnChangedTextureID()
+        {
+            ImGuiNative.ImDrawList__OnChangedTextureID((ImDrawList*)(NativePtr));
+        }
+        public void _OnChangedVtxOffset()
+        {
+            ImGuiNative.ImDrawList__OnChangedVtxOffset((ImDrawList*)(NativePtr));
+        }
+        public void _PathArcToFastEx(Vector2 center, float radius, int a_min_sample, int a_max_sample, int a_step)
+        {
+            ImGuiNative.ImDrawList__PathArcToFastEx((ImDrawList*)(NativePtr), center, radius, a_min_sample, a_max_sample, a_step);
+        }
+        public void _PathArcToN(Vector2 center, float radius, float a_min, float a_max, int num_segments)
+        {
+            ImGuiNative.ImDrawList__PathArcToN((ImDrawList*)(NativePtr), center, radius, a_min, a_max, num_segments);
+        }
+        public void _PopUnusedDrawCmd()
+        {
+            ImGuiNative.ImDrawList__PopUnusedDrawCmd((ImDrawList*)(NativePtr));
+        }
+        public void _ResetForNewFrame()
+        {
+            ImGuiNative.ImDrawList__ResetForNewFrame((ImDrawList*)(NativePtr));
+        }
+        public void _SetTextureID(IntPtr texture_id)
+        {
+            ImGuiNative.ImDrawList__SetTextureID((ImDrawList*)(NativePtr), texture_id);
+        }
+        public void _TryMergeDrawCmds()
+        {
+            ImGuiNative.ImDrawList__TryMergeDrawCmds((ImDrawList*)(NativePtr));
+        }
+        public void AddBezierCubic(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
+        {
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_AddBezierCubic((ImDrawList*)(NativePtr), p1, p2, p3, p4, col, thickness, num_segments);
+        }
+        public void AddBezierCubic(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness, int num_segments)
+        {
+            ImGuiNative.ImDrawList_AddBezierCubic((ImDrawList*)(NativePtr), p1, p2, p3, p4, col, thickness, num_segments);
+        }
+        public void AddBezierQuadratic(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
         {
             int num_segments = 0;
-            ImGuiNative.ImDrawList_AddBezierCurve(NativePtr, pos0, cp0, cp1, pos1, col, thickness, num_segments);
+            ImGuiNative.ImDrawList_AddBezierQuadratic((ImDrawList*)(NativePtr), p1, p2, p3, col, thickness, num_segments);
+        }
+        public void AddBezierQuadratic(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness, int num_segments)
+        {
+            ImGuiNative.ImDrawList_AddBezierQuadratic((ImDrawList*)(NativePtr), p1, p2, p3, col, thickness, num_segments);
         }
-        public void AddBezierCurve(Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness, int num_segments)
+        public void AddCallback(IntPtr callback, IntPtr userdata)
         {
-            ImGuiNative.ImDrawList_AddBezierCurve(NativePtr, pos0, cp0, cp1, pos1, col, thickness, num_segments);
+            void* native_userdata = (void*)userdata.ToPointer();
+            uint userdata_size = 0;
+            ImGuiNative.ImDrawList_AddCallback((ImDrawList*)(NativePtr), callback, native_userdata, userdata_size);
         }
-        public void AddCallback(IntPtr callback, IntPtr callback_data)
+        public void AddCallback(IntPtr callback, IntPtr userdata, uint userdata_size)
         {
-            void* native_callback_data = (void*)callback_data.ToPointer();
-            ImGuiNative.ImDrawList_AddCallback(NativePtr, callback, native_callback_data);
+            void* native_userdata = (void*)userdata.ToPointer();
+            ImGuiNative.ImDrawList_AddCallback((ImDrawList*)(NativePtr), callback, native_userdata, userdata_size);
         }
-        public void AddCircle(Vector2 centre, float radius, uint col)
+        public void AddCircle(Vector2 center, float radius, uint col)
         {
-            int num_segments = 12;
+            int num_segments = 0;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
+            ImGuiNative.ImDrawList_AddCircle((ImDrawList*)(NativePtr), center, radius, col, num_segments, thickness);
         }
-        public void AddCircle(Vector2 centre, float radius, uint col, int num_segments)
+        public void AddCircle(Vector2 center, float radius, uint col, int num_segments)
         {
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
+            ImGuiNative.ImDrawList_AddCircle((ImDrawList*)(NativePtr), center, radius, col, num_segments, thickness);
+        }
+        public void AddCircle(Vector2 center, float radius, uint col, int num_segments, float thickness)
+        {
+            ImGuiNative.ImDrawList_AddCircle((ImDrawList*)(NativePtr), center, radius, col, num_segments, thickness);
         }
-        public void AddCircle(Vector2 centre, float radius, uint col, int num_segments, float thickness)
+        public void AddCircleFilled(Vector2 center, float radius, uint col)
         {
-            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_AddCircleFilled((ImDrawList*)(NativePtr), center, radius, col, num_segments);
         }
-        public void AddCircleFilled(Vector2 centre, float radius, uint col)
+        public void AddCircleFilled(Vector2 center, float radius, uint col, int num_segments)
         {
-            int num_segments = 12;
-            ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, centre, radius, col, num_segments);
+            ImGuiNative.ImDrawList_AddCircleFilled((ImDrawList*)(NativePtr), center, radius, col, num_segments);
         }
-        public void AddCircleFilled(Vector2 centre, float radius, uint col, int num_segments)
+        public void AddConcavePolyFilled(ref Vector2 points, int num_points, uint col)
         {
-            ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, centre, radius, col, num_segments);
+            fixed (Vector2* native_points = &points)
+            {
+                ImGuiNative.ImDrawList_AddConcavePolyFilled((ImDrawList*)(NativePtr), native_points, num_points, col);
+            }
         }
         public void AddConvexPolyFilled(ref Vector2 points, int num_points, uint col)
         {
             fixed (Vector2* native_points = &points)
             {
-                ImGuiNative.ImDrawList_AddConvexPolyFilled(NativePtr, native_points, num_points, col);
+                ImGuiNative.ImDrawList_AddConvexPolyFilled((ImDrawList*)(NativePtr), native_points, num_points, col);
             }
         }
         public void AddDrawCmd()
         {
-            ImGuiNative.ImDrawList_AddDrawCmd(NativePtr);
+            ImGuiNative.ImDrawList_AddDrawCmd((ImDrawList*)(NativePtr));
+        }
+        public void AddEllipse(Vector2 center, Vector2 radius, uint col)
+        {
+            float rot = 0.0f;
+            int num_segments = 0;
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddEllipse((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments, thickness);
+        }
+        public void AddEllipse(Vector2 center, Vector2 radius, uint col, float rot)
+        {
+            int num_segments = 0;
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddEllipse((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments, thickness);
+        }
+        public void AddEllipse(Vector2 center, Vector2 radius, uint col, float rot, int num_segments)
+        {
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddEllipse((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments, thickness);
+        }
+        public void AddEllipse(Vector2 center, Vector2 radius, uint col, float rot, int num_segments, float thickness)
+        {
+            ImGuiNative.ImDrawList_AddEllipse((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments, thickness);
+        }
+        public void AddEllipseFilled(Vector2 center, Vector2 radius, uint col)
+        {
+            float rot = 0.0f;
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_AddEllipseFilled((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments);
+        }
+        public void AddEllipseFilled(Vector2 center, Vector2 radius, uint col, float rot)
+        {
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_AddEllipseFilled((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments);
+        }
+        public void AddEllipseFilled(Vector2 center, Vector2 radius, uint col, float rot, int num_segments)
+        {
+            ImGuiNative.ImDrawList_AddEllipseFilled((ImDrawList*)(NativePtr), center, radius, col, rot, num_segments);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b)
+        public void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max)
         {
-            Vector2 uv_a = new Vector2();
-            Vector2 uv_b = new Vector2(1, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
+            Vector2 uv_min = new Vector2();
+            Vector2 uv_max = new Vector2(1, 1);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImage((ImDrawList*)(NativePtr), user_texture_id, p_min, p_max, uv_min, uv_max, col);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a)
+        public void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min)
         {
-            Vector2 uv_b = new Vector2(1, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
+            Vector2 uv_max = new Vector2(1, 1);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImage((ImDrawList*)(NativePtr), user_texture_id, p_min, p_max, uv_min, uv_max, col);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b)
+        public void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max)
         {
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImage((ImDrawList*)(NativePtr), user_texture_id, p_min, p_max, uv_min, uv_max, col);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
+        public void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col)
         {
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
+            ImGuiNative.ImDrawList_AddImage((ImDrawList*)(NativePtr), user_texture_id, p_min, p_max, uv_min, uv_max, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4)
         {
-            Vector2 uv_a = new Vector2();
-            Vector2 uv_b = new Vector2(1, 0);
-            Vector2 uv_c = new Vector2(1, 1);
-            Vector2 uv_d = new Vector2(0, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            Vector2 uv1 = new Vector2();
+            Vector2 uv2 = new Vector2(1, 0);
+            Vector2 uv3 = new Vector2(1, 1);
+            Vector2 uv4 = new Vector2(0, 1);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImageQuad((ImDrawList*)(NativePtr), user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1)
         {
-            Vector2 uv_b = new Vector2(1, 0);
-            Vector2 uv_c = new Vector2(1, 1);
-            Vector2 uv_d = new Vector2(0, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            Vector2 uv2 = new Vector2(1, 0);
+            Vector2 uv3 = new Vector2(1, 1);
+            Vector2 uv4 = new Vector2(0, 1);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImageQuad((ImDrawList*)(NativePtr), user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2)
         {
-            Vector2 uv_c = new Vector2(1, 1);
-            Vector2 uv_d = new Vector2(0, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            Vector2 uv3 = new Vector2(1, 1);
+            Vector2 uv4 = new Vector2(0, 1);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImageQuad((ImDrawList*)(NativePtr), user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3)
         {
-            Vector2 uv_d = new Vector2(0, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            Vector2 uv4 = new Vector2(0, 1);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImageQuad((ImDrawList*)(NativePtr), user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4)
         {
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            uint col = 4294967295;
+            ImGuiNative.ImDrawList_AddImageQuad((ImDrawList*)(NativePtr), user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4, uint col)
         {
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            ImGuiNative.ImDrawList_AddImageQuad((ImDrawList*)(NativePtr), user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
         }
-        public void AddImageRounded(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding)
+        public void AddImageRounded(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding)
         {
-            int rounding_corners = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, a, b, uv_a, uv_b, col, rounding, rounding_corners);
+            ImDrawFlags flags = (ImDrawFlags)0;
+            ImGuiNative.ImDrawList_AddImageRounded((ImDrawList*)(NativePtr), user_texture_id, p_min, p_max, uv_min, uv_max, col, rounding, flags);
         }
-        public void AddImageRounded(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding, int rounding_corners)
+        public void AddImageRounded(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding, ImDrawFlags flags)
         {
-            ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, a, b, uv_a, uv_b, col, rounding, rounding_corners);
+            ImGuiNative.ImDrawList_AddImageRounded((ImDrawList*)(NativePtr), user_texture_id, p_min, p_max, uv_min, uv_max, col, rounding, flags);
         }
-        public void AddLine(Vector2 a, Vector2 b, uint col)
+        public void AddLine(Vector2 p1, Vector2 p2, uint col)
         {
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddLine(NativePtr, a, b, col, thickness);
+            ImGuiNative.ImDrawList_AddLine((ImDrawList*)(NativePtr), p1, p2, col, thickness);
         }
-        public void AddLine(Vector2 a, Vector2 b, uint col, float thickness)
+        public void AddLine(Vector2 p1, Vector2 p2, uint col, float thickness)
         {
-            ImGuiNative.ImDrawList_AddLine(NativePtr, a, b, col, thickness);
+            ImGuiNative.ImDrawList_AddLine((ImDrawList*)(NativePtr), p1, p2, col, thickness);
         }
-        public void AddPolyline(ref Vector2 points, int num_points, uint col, bool closed, float thickness)
+        public void AddNgon(Vector2 center, float radius, uint col, int num_segments)
+        {
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddNgon((ImDrawList*)(NativePtr), center, radius, col, num_segments, thickness);
+        }
+        public void AddNgon(Vector2 center, float radius, uint col, int num_segments, float thickness)
+        {
+            ImGuiNative.ImDrawList_AddNgon((ImDrawList*)(NativePtr), center, radius, col, num_segments, thickness);
+        }
+        public void AddNgonFilled(Vector2 center, float radius, uint col, int num_segments)
+        {
+            ImGuiNative.ImDrawList_AddNgonFilled((ImDrawList*)(NativePtr), center, radius, col, num_segments);
+        }
+        public void AddPolyline(ref Vector2 points, int num_points, uint col, ImDrawFlags flags, float thickness)
         {
-            byte native_closed = closed ? (byte)1 : (byte)0;
             fixed (Vector2* native_points = &points)
             {
-                ImGuiNative.ImDrawList_AddPolyline(NativePtr, native_points, num_points, col, native_closed, thickness);
+                ImGuiNative.ImDrawList_AddPolyline((ImDrawList*)(NativePtr), native_points, num_points, col, flags, thickness);
             }
         }
-        public void AddQuad(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col)
+        public void AddQuad(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
         {
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddQuad(NativePtr, a, b, c, d, col, thickness);
+            ImGuiNative.ImDrawList_AddQuad((ImDrawList*)(NativePtr), p1, p2, p3, p4, col, thickness);
         }
-        public void AddQuad(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col, float thickness)
+        public void AddQuad(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
         {
-            ImGuiNative.ImDrawList_AddQuad(NativePtr, a, b, c, d, col, thickness);
+            ImGuiNative.ImDrawList_AddQuad((ImDrawList*)(NativePtr), p1, p2, p3, p4, col, thickness);
         }
-        public void AddQuadFilled(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col)
+        public void AddQuadFilled(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
         {
-            ImGuiNative.ImDrawList_AddQuadFilled(NativePtr, a, b, c, d, col);
+            ImGuiNative.ImDrawList_AddQuadFilled((ImDrawList*)(NativePtr), p1, p2, p3, p4, col);
         }
-        public void AddRect(Vector2 a, Vector2 b, uint col)
+        public void AddRect(Vector2 p_min, Vector2 p_max, uint col)
         {
             float rounding = 0.0f;
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
+            ImDrawFlags flags = (ImDrawFlags)0;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddRect(NativePtr, a, b, col, rounding, rounding_corners_flags, thickness);
+            ImGuiNative.ImDrawList_AddRect((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags, thickness);
         }
-        public void AddRect(Vector2 a, Vector2 b, uint col, float rounding)
+        public void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding)
         {
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
+            ImDrawFlags flags = (ImDrawFlags)0;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddRect(NativePtr, a, b, col, rounding, rounding_corners_flags, thickness);
+            ImGuiNative.ImDrawList_AddRect((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags, thickness);
         }
-        public void AddRect(Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags)
+        public void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags)
         {
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddRect(NativePtr, a, b, col, rounding, rounding_corners_flags, thickness);
+            ImGuiNative.ImDrawList_AddRect((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags, thickness);
         }
-        public void AddRect(Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags, float thickness)
+        public void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags, float thickness)
         {
-            ImGuiNative.ImDrawList_AddRect(NativePtr, a, b, col, rounding, rounding_corners_flags, thickness);
+            ImGuiNative.ImDrawList_AddRect((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags, thickness);
         }
-        public void AddRectFilled(Vector2 a, Vector2 b, uint col)
+        public void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col)
         {
             float rounding = 0.0f;
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
+            ImDrawFlags flags = (ImDrawFlags)0;
+            ImGuiNative.ImDrawList_AddRectFilled((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags);
         }
-        public void AddRectFilled(Vector2 a, Vector2 b, uint col, float rounding)
+        public void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col, float rounding)
         {
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
+            ImDrawFlags flags = (ImDrawFlags)0;
+            ImGuiNative.ImDrawList_AddRectFilled((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags);
         }
-        public void AddRectFilled(Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags)
+        public void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags)
         {
-            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
+            ImGuiNative.ImDrawList_AddRectFilled((ImDrawList*)(NativePtr), p_min, p_max, col, rounding, flags);
         }
-        public void AddRectFilledMultiColor(Vector2 a, Vector2 b, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left)
+        public void AddRectFilledMultiColor(Vector2 p_min, Vector2 p_max, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left)
         {
-            ImGuiNative.ImDrawList_AddRectFilledMultiColor(NativePtr, a, b, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
+            ImGuiNative.ImDrawList_AddRectFilledMultiColor((ImDrawList*)(NativePtr), p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
         }
-        public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, uint col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void AddText(Vector2 pos, uint col, ReadOnlySpan<char> text_begin)
         {
-            float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddTriangle(NativePtr, a, b, c, col, thickness);
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            ImGuiNative.ImDrawList_AddText_Vec2((ImDrawList*)(NativePtr), pos, col, native_text_begin, native_text_begin+text_begin_byteCount);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
         }
-        public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, uint col, float thickness)
-        {
-            ImGuiNative.ImDrawList_AddTriangle(NativePtr, a, b, c, col, thickness);
+#endif
+        public void AddText(Vector2 pos, uint col, string text_begin)
+        {
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            ImGuiNative.ImDrawList_AddText_Vec2((ImDrawList*)(NativePtr), pos, col, native_text_begin, native_text_begin+text_begin_byteCount);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, ReadOnlySpan<char> text_begin)
+        {
+            ImFont* native_font = font.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            float wrap_width = 0.0f;
+            Vector4* cpu_fine_clip_rect = null;
+            ImGuiNative.ImDrawList_AddText_FontPtr((ImDrawList*)(NativePtr), native_font, font_size, pos, col, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip_rect);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#endif
+        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin)
+        {
+            ImFont* native_font = font.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            float wrap_width = 0.0f;
+            Vector4* cpu_fine_clip_rect = null;
+            ImGuiNative.ImDrawList_AddText_FontPtr((ImDrawList*)(NativePtr), native_font, font_size, pos, col, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip_rect);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, ReadOnlySpan<char> text_begin, float wrap_width)
+        {
+            ImFont* native_font = font.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            Vector4* cpu_fine_clip_rect = null;
+            ImGuiNative.ImDrawList_AddText_FontPtr((ImDrawList*)(NativePtr), native_font, font_size, pos, col, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip_rect);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#endif
+        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin, float wrap_width)
+        {
+            ImFont* native_font = font.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            Vector4* cpu_fine_clip_rect = null;
+            ImGuiNative.ImDrawList_AddText_FontPtr((ImDrawList*)(NativePtr), native_font, font_size, pos, col, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip_rect);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, ReadOnlySpan<char> text_begin, float wrap_width, ref Vector4 cpu_fine_clip_rect)
+        {
+            ImFont* native_font = font.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            fixed (Vector4* native_cpu_fine_clip_rect = &cpu_fine_clip_rect)
+            {
+                ImGuiNative.ImDrawList_AddText_FontPtr((ImDrawList*)(NativePtr), native_font, font_size, pos, col, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, native_cpu_fine_clip_rect);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_text_begin);
+                }
+            }
         }
-        public void AddTriangleFilled(Vector2 a, Vector2 b, Vector2 c, uint col)
+#endif
+        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin, float wrap_width, ref Vector4 cpu_fine_clip_rect)
+        {
+            ImFont* native_font = font.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            fixed (Vector4* native_cpu_fine_clip_rect = &cpu_fine_clip_rect)
+            {
+                ImGuiNative.ImDrawList_AddText_FontPtr((ImDrawList*)(NativePtr), native_font, font_size, pos, col, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, native_cpu_fine_clip_rect);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_text_begin);
+                }
+            }
+        }
+        public void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
         {
-            ImGuiNative.ImDrawList_AddTriangleFilled(NativePtr, a, b, c, col);
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddTriangle((ImDrawList*)(NativePtr), p1, p2, p3, col, thickness);
         }
-        public void ChannelsMerge()
+        public void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
         {
-            ImGuiNative.ImDrawList_ChannelsMerge(NativePtr);
+            ImGuiNative.ImDrawList_AddTriangle((ImDrawList*)(NativePtr), p1, p2, p3, col, thickness);
         }
-        public void ChannelsSetCurrent(int channel_index)
+        public void AddTriangleFilled(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
         {
-            ImGuiNative.ImDrawList_ChannelsSetCurrent(NativePtr, channel_index);
+            ImGuiNative.ImDrawList_AddTriangleFilled((ImDrawList*)(NativePtr), p1, p2, p3, col);
         }
-        public void ChannelsSplit(int channels_count)
+        public void ChannelsMerge()
         {
-            ImGuiNative.ImDrawList_ChannelsSplit(NativePtr, channels_count);
+            ImGuiNative.ImDrawList_ChannelsMerge((ImDrawList*)(NativePtr));
         }
-        public void Clear()
+        public void ChannelsSetCurrent(int n)
         {
-            ImGuiNative.ImDrawList_Clear(NativePtr);
+            ImGuiNative.ImDrawList_ChannelsSetCurrent((ImDrawList*)(NativePtr), n);
         }
-        public void ClearFreeMemory()
+        public void ChannelsSplit(int count)
         {
-            ImGuiNative.ImDrawList_ClearFreeMemory(NativePtr);
+            ImGuiNative.ImDrawList_ChannelsSplit((ImDrawList*)(NativePtr), count);
         }
         public ImDrawListPtr CloneOutput()
         {
-            ImDrawList* ret = ImGuiNative.ImDrawList_CloneOutput(NativePtr);
+            ImDrawList* ret = ImGuiNative.ImDrawList_CloneOutput((ImDrawList*)(NativePtr));
             return new ImDrawListPtr(ret);
         }
+        public void Destroy()
+        {
+            ImGuiNative.ImDrawList_destroy((ImDrawList*)(NativePtr));
+        }
         public Vector2 GetClipRectMax()
         {
-            Vector2 ret = ImGuiNative.ImDrawList_GetClipRectMax(NativePtr);
-            return ret;
+            Vector2 __retval;
+            ImGuiNative.ImDrawList_GetClipRectMax(&__retval, (ImDrawList*)(NativePtr));
+            return __retval;
         }
         public Vector2 GetClipRectMin()
         {
-            Vector2 ret = ImGuiNative.ImDrawList_GetClipRectMin(NativePtr);
-            return ret;
+            Vector2 __retval;
+            ImGuiNative.ImDrawList_GetClipRectMin(&__retval, (ImDrawList*)(NativePtr));
+            return __retval;
+        }
+        public void PathArcTo(Vector2 center, float radius, float a_min, float a_max)
+        {
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_PathArcTo((ImDrawList*)(NativePtr), center, radius, a_min, a_max, num_segments);
+        }
+        public void PathArcTo(Vector2 center, float radius, float a_min, float a_max, int num_segments)
+        {
+            ImGuiNative.ImDrawList_PathArcTo((ImDrawList*)(NativePtr), center, radius, a_min, a_max, num_segments);
         }
-        public void PathArcTo(Vector2 centre, float radius, float a_min, float a_max)
+        public void PathArcToFast(Vector2 center, float radius, int a_min_of_12, int a_max_of_12)
         {
-            int num_segments = 10;
-            ImGuiNative.ImDrawList_PathArcTo(NativePtr, centre, radius, a_min, a_max, num_segments);
+            ImGuiNative.ImDrawList_PathArcToFast((ImDrawList*)(NativePtr), center, radius, a_min_of_12, a_max_of_12);
         }
-        public void PathArcTo(Vector2 centre, float radius, float a_min, float a_max, int num_segments)
+        public void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4)
         {
-            ImGuiNative.ImDrawList_PathArcTo(NativePtr, centre, radius, a_min, a_max, num_segments);
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_PathBezierCubicCurveTo((ImDrawList*)(NativePtr), p2, p3, p4, num_segments);
         }
-        public void PathArcToFast(Vector2 centre, float radius, int a_min_of_12, int a_max_of_12)
+        public void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4, int num_segments)
         {
-            ImGuiNative.ImDrawList_PathArcToFast(NativePtr, centre, radius, a_min_of_12, a_max_of_12);
+            ImGuiNative.ImDrawList_PathBezierCubicCurveTo((ImDrawList*)(NativePtr), p2, p3, p4, num_segments);
         }
-        public void PathBezierCurveTo(Vector2 p1, Vector2 p2, Vector2 p3)
+        public void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3)
         {
             int num_segments = 0;
-            ImGuiNative.ImDrawList_PathBezierCurveTo(NativePtr, p1, p2, p3, num_segments);
+            ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo((ImDrawList*)(NativePtr), p2, p3, num_segments);
         }
-        public void PathBezierCurveTo(Vector2 p1, Vector2 p2, Vector2 p3, int num_segments)
+        public void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3, int num_segments)
         {
-            ImGuiNative.ImDrawList_PathBezierCurveTo(NativePtr, p1, p2, p3, num_segments);
+            ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo((ImDrawList*)(NativePtr), p2, p3, num_segments);
         }
         public void PathClear()
         {
-            ImGuiNative.ImDrawList_PathClear(NativePtr);
+            ImGuiNative.ImDrawList_PathClear((ImDrawList*)(NativePtr));
+        }
+        public void PathEllipticalArcTo(Vector2 center, Vector2 radius, float rot, float a_min, float a_max)
+        {
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_PathEllipticalArcTo((ImDrawList*)(NativePtr), center, radius, rot, a_min, a_max, num_segments);
+        }
+        public void PathEllipticalArcTo(Vector2 center, Vector2 radius, float rot, float a_min, float a_max, int num_segments)
+        {
+            ImGuiNative.ImDrawList_PathEllipticalArcTo((ImDrawList*)(NativePtr), center, radius, rot, a_min, a_max, num_segments);
+        }
+        public void PathFillConcave(uint col)
+        {
+            ImGuiNative.ImDrawList_PathFillConcave((ImDrawList*)(NativePtr), col);
         }
         public void PathFillConvex(uint col)
         {
-            ImGuiNative.ImDrawList_PathFillConvex(NativePtr, col);
+            ImGuiNative.ImDrawList_PathFillConvex((ImDrawList*)(NativePtr), col);
         }
         public void PathLineTo(Vector2 pos)
         {
-            ImGuiNative.ImDrawList_PathLineTo(NativePtr, pos);
+            ImGuiNative.ImDrawList_PathLineTo((ImDrawList*)(NativePtr), pos);
         }
         public void PathLineToMergeDuplicate(Vector2 pos)
         {
-            ImGuiNative.ImDrawList_PathLineToMergeDuplicate(NativePtr, pos);
+            ImGuiNative.ImDrawList_PathLineToMergeDuplicate((ImDrawList*)(NativePtr), pos);
         }
         public void PathRect(Vector2 rect_min, Vector2 rect_max)
         {
             float rounding = 0.0f;
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
+            ImDrawFlags flags = (ImDrawFlags)0;
+            ImGuiNative.ImDrawList_PathRect((ImDrawList*)(NativePtr), rect_min, rect_max, rounding, flags);
         }
         public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding)
         {
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
+            ImDrawFlags flags = (ImDrawFlags)0;
+            ImGuiNative.ImDrawList_PathRect((ImDrawList*)(NativePtr), rect_min, rect_max, rounding, flags);
+        }
+        public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding, ImDrawFlags flags)
+        {
+            ImGuiNative.ImDrawList_PathRect((ImDrawList*)(NativePtr), rect_min, rect_max, rounding, flags);
         }
-        public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding, int rounding_corners_flags)
+        public void PathStroke(uint col)
         {
-            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
+            ImDrawFlags flags = (ImDrawFlags)0;
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_PathStroke((ImDrawList*)(NativePtr), col, flags, thickness);
         }
-        public void PathStroke(uint col, bool closed)
+        public void PathStroke(uint col, ImDrawFlags flags)
         {
-            byte native_closed = closed ? (byte)1 : (byte)0;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_PathStroke(NativePtr, col, native_closed, thickness);
+            ImGuiNative.ImDrawList_PathStroke((ImDrawList*)(NativePtr), col, flags, thickness);
         }
-        public void PathStroke(uint col, bool closed, float thickness)
+        public void PathStroke(uint col, ImDrawFlags flags, float thickness)
         {
-            byte native_closed = closed ? (byte)1 : (byte)0;
-            ImGuiNative.ImDrawList_PathStroke(NativePtr, col, native_closed, thickness);
+            ImGuiNative.ImDrawList_PathStroke((ImDrawList*)(NativePtr), col, flags, thickness);
         }
         public void PopClipRect()
         {
-            ImGuiNative.ImDrawList_PopClipRect(NativePtr);
+            ImGuiNative.ImDrawList_PopClipRect((ImDrawList*)(NativePtr));
         }
         public void PopTextureID()
         {
-            ImGuiNative.ImDrawList_PopTextureID(NativePtr);
+            ImGuiNative.ImDrawList_PopTextureID((ImDrawList*)(NativePtr));
         }
         public void PrimQuadUV(Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
         {
-            ImGuiNative.ImDrawList_PrimQuadUV(NativePtr, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            ImGuiNative.ImDrawList_PrimQuadUV((ImDrawList*)(NativePtr), a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
         public void PrimRect(Vector2 a, Vector2 b, uint col)
         {
-            ImGuiNative.ImDrawList_PrimRect(NativePtr, a, b, col);
+            ImGuiNative.ImDrawList_PrimRect((ImDrawList*)(NativePtr), a, b, col);
         }
         public void PrimRectUV(Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
         {
-            ImGuiNative.ImDrawList_PrimRectUV(NativePtr, a, b, uv_a, uv_b, col);
+            ImGuiNative.ImDrawList_PrimRectUV((ImDrawList*)(NativePtr), a, b, uv_a, uv_b, col);
         }
         public void PrimReserve(int idx_count, int vtx_count)
         {
-            ImGuiNative.ImDrawList_PrimReserve(NativePtr, idx_count, vtx_count);
+            ImGuiNative.ImDrawList_PrimReserve((ImDrawList*)(NativePtr), idx_count, vtx_count);
+        }
+        public void PrimUnreserve(int idx_count, int vtx_count)
+        {
+            ImGuiNative.ImDrawList_PrimUnreserve((ImDrawList*)(NativePtr), idx_count, vtx_count);
         }
         public void PrimVtx(Vector2 pos, Vector2 uv, uint col)
         {
-            ImGuiNative.ImDrawList_PrimVtx(NativePtr, pos, uv, col);
+            ImGuiNative.ImDrawList_PrimVtx((ImDrawList*)(NativePtr), pos, uv, col);
         }
         public void PrimWriteIdx(ushort idx)
         {
-            ImGuiNative.ImDrawList_PrimWriteIdx(NativePtr, idx);
+            ImGuiNative.ImDrawList_PrimWriteIdx((ImDrawList*)(NativePtr), idx);
         }
         public void PrimWriteVtx(Vector2 pos, Vector2 uv, uint col)
         {
-            ImGuiNative.ImDrawList_PrimWriteVtx(NativePtr, pos, uv, col);
+            ImGuiNative.ImDrawList_PrimWriteVtx((ImDrawList*)(NativePtr), pos, uv, col);
         }
         public void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max)
         {
             byte intersect_with_current_clip_rect = 0;
-            ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
+            ImGuiNative.ImDrawList_PushClipRect((ImDrawList*)(NativePtr), clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
         }
         public void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
         {
             byte native_intersect_with_current_clip_rect = intersect_with_current_clip_rect ? (byte)1 : (byte)0;
-            ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, native_intersect_with_current_clip_rect);
+            ImGuiNative.ImDrawList_PushClipRect((ImDrawList*)(NativePtr), clip_rect_min, clip_rect_max, native_intersect_with_current_clip_rect);
         }
         public void PushClipRectFullScreen()
         {
-            ImGuiNative.ImDrawList_PushClipRectFullScreen(NativePtr);
+            ImGuiNative.ImDrawList_PushClipRectFullScreen((ImDrawList*)(NativePtr));
         }
         public void PushTextureID(IntPtr texture_id)
         {
-            ImGuiNative.ImDrawList_PushTextureID(NativePtr, texture_id);
-        }
-        public void UpdateClipRect()
-        {
-            ImGuiNative.ImDrawList_UpdateClipRect(NativePtr);
-        }
-        public void UpdateTextureID()
-        {
-            ImGuiNative.ImDrawList_UpdateTextureID(NativePtr);
+            ImGuiNative.ImDrawList_PushTextureID((ImDrawList*)(NativePtr), texture_id);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImDrawListFlags.gen.cs b/src/ImGui.NET/Generated/ImDrawListFlags.gen.cs
index 1adb3d08..e55321f1 100644
--- a/src/ImGui.NET/Generated/ImDrawListFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImDrawListFlags.gen.cs
@@ -4,7 +4,9 @@ namespace ImGuiNET
     public enum ImDrawListFlags
     {
         None = 0,
-        AntiAliasedLines = 1 << 0,
-        AntiAliasedFill = 1 << 1,
+        AntiAliasedLines = 1,
+        AntiAliasedLinesUseTex = 2,
+        AntiAliasedFill = 4,
+        AllowVtxOffset = 8,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImDrawListSplitter.gen.cs b/src/ImGui.NET/Generated/ImDrawListSplitter.gen.cs
new file mode 100644
index 00000000..9c180e71
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImDrawListSplitter.gen.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImDrawListSplitter
+    {
+        public int _Current;
+        public int _Count;
+        public ImVector _Channels;
+    }
+    public unsafe partial struct ImDrawListSplitterPtr
+    {
+        public ImDrawListSplitter* NativePtr { get; }
+        public ImDrawListSplitterPtr(ImDrawListSplitter* nativePtr) => NativePtr = nativePtr;
+        public ImDrawListSplitterPtr(IntPtr nativePtr) => NativePtr = (ImDrawListSplitter*)nativePtr;
+        public static implicit operator ImDrawListSplitterPtr(ImDrawListSplitter* nativePtr) => new ImDrawListSplitterPtr(nativePtr);
+        public static implicit operator ImDrawListSplitter* (ImDrawListSplitterPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImDrawListSplitterPtr(IntPtr nativePtr) => new ImDrawListSplitterPtr(nativePtr);
+        public ref int _Current => ref Unsafe.AsRef<int>(&NativePtr->_Current);
+        public ref int _Count => ref Unsafe.AsRef<int>(&NativePtr->_Count);
+        public ImPtrVector<ImDrawChannelPtr> _Channels => new ImPtrVector<ImDrawChannelPtr>(NativePtr->_Channels, Unsafe.SizeOf<ImDrawChannel>());
+        public void Clear()
+        {
+            ImGuiNative.ImDrawListSplitter_Clear((ImDrawListSplitter*)(NativePtr));
+        }
+        public void ClearFreeMemory()
+        {
+            ImGuiNative.ImDrawListSplitter_ClearFreeMemory((ImDrawListSplitter*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImDrawListSplitter_destroy((ImDrawListSplitter*)(NativePtr));
+        }
+        public void Merge(ImDrawListPtr draw_list)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            ImGuiNative.ImDrawListSplitter_Merge((ImDrawListSplitter*)(NativePtr), native_draw_list);
+        }
+        public void SetCurrentChannel(ImDrawListPtr draw_list, int channel_idx)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            ImGuiNative.ImDrawListSplitter_SetCurrentChannel((ImDrawListSplitter*)(NativePtr), native_draw_list, channel_idx);
+        }
+        public void Split(ImDrawListPtr draw_list, int count)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            ImGuiNative.ImDrawListSplitter_Split((ImDrawListSplitter*)(NativePtr), native_draw_list, count);
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImFont.gen.cs b/src/ImGui.NET/Generated/ImFont.gen.cs
index 2e6a6c2d..ded8d7a5 100644
--- a/src/ImGui.NET/Generated/ImFont.gen.cs
+++ b/src/ImGui.NET/Generated/ImFont.gen.cs
@@ -7,22 +7,26 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImFont
     {
-        public float FontSize;
-        public float Scale;
-        public Vector2 DisplayOffset;
-        public ImVector Glyphs;
         public ImVector IndexAdvanceX;
+        public float FallbackAdvanceX;
+        public float FontSize;
         public ImVector IndexLookup;
+        public ImVector Glyphs;
         public ImFontGlyph* FallbackGlyph;
-        public float FallbackAdvanceX;
-        public ushort FallbackChar;
-        public short ConfigDataCount;
-        public ImFontConfig* ConfigData;
         public ImFontAtlas* ContainerAtlas;
+        public ImFontConfig* ConfigData;
+        public short ConfigDataCount;
+        public short EllipsisCharCount;
+        public ushort EllipsisChar;
+        public ushort FallbackChar;
+        public float EllipsisWidth;
+        public float EllipsisCharStep;
+        public byte DirtyLookupTables;
+        public float Scale;
         public float Ascent;
         public float Descent;
-        public byte DirtyLookupTables;
         public int MetricsTotalSurface;
+        public fixed byte Used4kPagesMap[2];
     }
     public unsafe partial struct ImFontPtr
     {
@@ -32,81 +36,407 @@ public unsafe partial struct ImFontPtr
         public static implicit operator ImFontPtr(ImFont* nativePtr) => new ImFontPtr(nativePtr);
         public static implicit operator ImFont* (ImFontPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImFontPtr(IntPtr nativePtr) => new ImFontPtr(nativePtr);
-        public ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize);
-        public ref float Scale => ref Unsafe.AsRef<float>(&NativePtr->Scale);
-        public ref Vector2 DisplayOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayOffset);
-        public ImPtrVector<ImFontGlyphPtr> Glyphs => new ImPtrVector<ImFontGlyphPtr>(NativePtr->Glyphs, Unsafe.SizeOf<ImFontGlyph>());
         public ImVector<float> IndexAdvanceX => new ImVector<float>(NativePtr->IndexAdvanceX);
+        public ref float FallbackAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->FallbackAdvanceX);
+        public ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize);
         public ImVector<ushort> IndexLookup => new ImVector<ushort>(NativePtr->IndexLookup);
+        public ImPtrVector<ImFontGlyphPtr> Glyphs => new ImPtrVector<ImFontGlyphPtr>(NativePtr->Glyphs, Unsafe.SizeOf<ImFontGlyph>());
         public ImFontGlyphPtr FallbackGlyph => new ImFontGlyphPtr(NativePtr->FallbackGlyph);
-        public ref float FallbackAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->FallbackAdvanceX);
-        public ref ushort FallbackChar => ref Unsafe.AsRef<ushort>(&NativePtr->FallbackChar);
-        public ref short ConfigDataCount => ref Unsafe.AsRef<short>(&NativePtr->ConfigDataCount);
-        public ImFontConfigPtr ConfigData => new ImFontConfigPtr(NativePtr->ConfigData);
         public ImFontAtlasPtr ContainerAtlas => new ImFontAtlasPtr(NativePtr->ContainerAtlas);
+        public ImFontConfigPtr ConfigData => new ImFontConfigPtr(NativePtr->ConfigData);
+        public ref short ConfigDataCount => ref Unsafe.AsRef<short>(&NativePtr->ConfigDataCount);
+        public ref short EllipsisCharCount => ref Unsafe.AsRef<short>(&NativePtr->EllipsisCharCount);
+        public ref ushort EllipsisChar => ref Unsafe.AsRef<ushort>(&NativePtr->EllipsisChar);
+        public ref ushort FallbackChar => ref Unsafe.AsRef<ushort>(&NativePtr->FallbackChar);
+        public ref float EllipsisWidth => ref Unsafe.AsRef<float>(&NativePtr->EllipsisWidth);
+        public ref float EllipsisCharStep => ref Unsafe.AsRef<float>(&NativePtr->EllipsisCharStep);
+        public ref bool DirtyLookupTables => ref Unsafe.AsRef<bool>(&NativePtr->DirtyLookupTables);
+        public ref float Scale => ref Unsafe.AsRef<float>(&NativePtr->Scale);
         public ref float Ascent => ref Unsafe.AsRef<float>(&NativePtr->Ascent);
         public ref float Descent => ref Unsafe.AsRef<float>(&NativePtr->Descent);
-        public ref bool DirtyLookupTables => ref Unsafe.AsRef<bool>(&NativePtr->DirtyLookupTables);
         public ref int MetricsTotalSurface => ref Unsafe.AsRef<int>(&NativePtr->MetricsTotalSurface);
-        public void AddGlyph(ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
+        public RangeAccessor<byte> Used4kPagesMap => new RangeAccessor<byte>(NativePtr->Used4kPagesMap, 2);
+        public void AddGlyph(ImFontConfigPtr src_cfg, ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
         {
-            ImGuiNative.ImFont_AddGlyph(NativePtr, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
+            ImFontConfig* native_src_cfg = src_cfg.NativePtr;
+            ImGuiNative.ImFont_AddGlyph((ImFont*)(NativePtr), native_src_cfg, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
         }
         public void AddRemapChar(ushort dst, ushort src)
         {
             byte overwrite_dst = 1;
-            ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, overwrite_dst);
+            ImGuiNative.ImFont_AddRemapChar((ImFont*)(NativePtr), dst, src, overwrite_dst);
         }
         public void AddRemapChar(ushort dst, ushort src, bool overwrite_dst)
         {
             byte native_overwrite_dst = overwrite_dst ? (byte)1 : (byte)0;
-            ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, native_overwrite_dst);
+            ImGuiNative.ImFont_AddRemapChar((ImFont*)(NativePtr), dst, src, native_overwrite_dst);
         }
         public void BuildLookupTable()
         {
-            ImGuiNative.ImFont_BuildLookupTable(NativePtr);
+            ImGuiNative.ImFont_BuildLookupTable((ImFont*)(NativePtr));
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, ReadOnlySpan<char> text_begin)
+        {
+            Vector2 __retval;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            byte** remaining = null;
+            ImGuiNative.ImFont_CalcTextSizeA(&__retval, (ImFont*)(NativePtr), size, max_width, wrap_width, native_text_begin, native_text_begin+text_begin_byteCount, remaining);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+            return __retval;
+        }
+#endif
+        public Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, string text_begin)
+        {
+            Vector2 __retval;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            byte** remaining = null;
+            ImGuiNative.ImFont_CalcTextSizeA(&__retval, (ImFont*)(NativePtr), size, max_width, wrap_width, native_text_begin, native_text_begin+text_begin_byteCount, remaining);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+            return __retval;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, ReadOnlySpan<char> text_begin, ref byte* remaining)
+        {
+            Vector2 __retval;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            fixed (byte** native_remaining = &remaining)
+            {
+                ImGuiNative.ImFont_CalcTextSizeA(&__retval, (ImFont*)(NativePtr), size, max_width, wrap_width, native_text_begin, native_text_begin+text_begin_byteCount, native_remaining);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_text_begin);
+                }
+                return __retval;
+            }
+        }
+#endif
+        public Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, string text_begin, ref byte* remaining)
+        {
+            Vector2 __retval;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            fixed (byte** native_remaining = &remaining)
+            {
+                ImGuiNative.ImFont_CalcTextSizeA(&__retval, (ImFont*)(NativePtr), size, max_width, wrap_width, native_text_begin, native_text_begin+text_begin_byteCount, native_remaining);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_text_begin);
+                }
+                return __retval;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public string CalcWordWrapPositionA(float scale, ReadOnlySpan<char> text, float wrap_width)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            byte* ret = ImGuiNative.ImFont_CalcWordWrapPositionA((ImFont*)(NativePtr), scale, native_text, native_text+text_byteCount, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+            return Util.StringFromPtr(ret);
+        }
+#endif
+        public string CalcWordWrapPositionA(float scale, string text, float wrap_width)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            byte* ret = ImGuiNative.ImFont_CalcWordWrapPositionA((ImFont*)(NativePtr), scale, native_text, native_text+text_byteCount, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+            return Util.StringFromPtr(ret);
         }
         public void ClearOutputData()
         {
-            ImGuiNative.ImFont_ClearOutputData(NativePtr);
+            ImGuiNative.ImFont_ClearOutputData((ImFont*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImFont_destroy((ImFont*)(NativePtr));
         }
         public ImFontGlyphPtr FindGlyph(ushort c)
         {
-            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyph(NativePtr, c);
+            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyph((ImFont*)(NativePtr), c);
             return new ImFontGlyphPtr(ret);
         }
         public ImFontGlyphPtr FindGlyphNoFallback(ushort c)
         {
-            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyphNoFallback(NativePtr, c);
+            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyphNoFallback((ImFont*)(NativePtr), c);
             return new ImFontGlyphPtr(ret);
         }
         public float GetCharAdvance(ushort c)
         {
-            float ret = ImGuiNative.ImFont_GetCharAdvance(NativePtr, c);
+            float ret = ImGuiNative.ImFont_GetCharAdvance((ImFont*)(NativePtr), c);
             return ret;
         }
         public string GetDebugName()
         {
-            byte* ret = ImGuiNative.ImFont_GetDebugName(NativePtr);
+            byte* ret = ImGuiNative.ImFont_GetDebugName((ImFont*)(NativePtr));
             return Util.StringFromPtr(ret);
         }
         public void GrowIndex(int new_size)
         {
-            ImGuiNative.ImFont_GrowIndex(NativePtr, new_size);
+            ImGuiNative.ImFont_GrowIndex((ImFont*)(NativePtr), new_size);
         }
         public bool IsLoaded()
         {
-            byte ret = ImGuiNative.ImFont_IsLoaded(NativePtr);
+            byte ret = ImGuiNative.ImFont_IsLoaded((ImFont*)(NativePtr));
             return ret != 0;
         }
         public void RenderChar(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, ushort c)
         {
             ImDrawList* native_draw_list = draw_list.NativePtr;
-            ImGuiNative.ImFont_RenderChar(NativePtr, native_draw_list, size, pos, col, c);
+            ImGuiNative.ImFont_RenderChar((ImFont*)(NativePtr), native_draw_list, size, pos, col, c);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, ReadOnlySpan<char> text_begin)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            float wrap_width = 0.0f;
+            byte cpu_fine_clip = 0;
+            ImGuiNative.ImFont_RenderText((ImFont*)(NativePtr), native_draw_list, size, pos, col, clip_rect, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#endif
+        public void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            float wrap_width = 0.0f;
+            byte cpu_fine_clip = 0;
+            ImGuiNative.ImFont_RenderText((ImFont*)(NativePtr), native_draw_list, size, pos, col, clip_rect, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, ReadOnlySpan<char> text_begin, float wrap_width)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            byte cpu_fine_clip = 0;
+            ImGuiNative.ImFont_RenderText((ImFont*)(NativePtr), native_draw_list, size, pos, col, clip_rect, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#endif
+        public void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin, float wrap_width)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            byte cpu_fine_clip = 0;
+            ImGuiNative.ImFont_RenderText((ImFont*)(NativePtr), native_draw_list, size, pos, col, clip_rect, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, cpu_fine_clip);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, ReadOnlySpan<char> text_begin, float wrap_width, bool cpu_fine_clip)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            byte native_cpu_fine_clip = cpu_fine_clip ? (byte)1 : (byte)0;
+            ImGuiNative.ImFont_RenderText((ImFont*)(NativePtr), native_draw_list, size, pos, col, clip_rect, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, native_cpu_fine_clip);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
+        }
+#endif
+        public void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin, float wrap_width, bool cpu_fine_clip)
+        {
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* native_text_begin;
+            int text_begin_byteCount = 0;
+                text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
+                if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text_begin = Util.Allocate(text_begin_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_begin_stackBytes = stackalloc byte[text_begin_byteCount + 1];
+                    native_text_begin = native_text_begin_stackBytes;
+                }
+                int native_text_begin_offset = Util.GetUtf8(text_begin, native_text_begin, text_begin_byteCount);
+                native_text_begin[native_text_begin_offset] = 0;
+            byte native_cpu_fine_clip = cpu_fine_clip ? (byte)1 : (byte)0;
+            ImGuiNative.ImFont_RenderText((ImFont*)(NativePtr), native_draw_list, size, pos, col, clip_rect, native_text_begin, native_text_begin+text_begin_byteCount, wrap_width, native_cpu_fine_clip);
+            if (text_begin_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text_begin);
+            }
         }
-        public void SetFallbackChar(ushort c)
+        public void SetGlyphVisible(ushort c, bool visible)
         {
-            ImGuiNative.ImFont_SetFallbackChar(NativePtr, c);
+            byte native_visible = visible ? (byte)1 : (byte)0;
+            ImGuiNative.ImFont_SetGlyphVisible((ImFont*)(NativePtr), c, native_visible);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImFontAtlas.gen.cs b/src/ImGui.NET/Generated/ImFontAtlas.gen.cs
index ead9719d..b4986221 100644
--- a/src/ImGui.NET/Generated/ImFontAtlas.gen.cs
+++ b/src/ImGui.NET/Generated/ImFontAtlas.gen.cs
@@ -7,11 +7,14 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImFontAtlas
     {
-        public byte Locked;
         public ImFontAtlasFlags Flags;
         public IntPtr TexID;
         public int TexDesiredWidth;
         public int TexGlyphPadding;
+        public byte Locked;
+        public void* UserData;
+        public byte TexReady;
+        public byte TexPixelsUseColors;
         public byte* TexPixelsAlpha8;
         public uint* TexPixelsRGBA32;
         public int TexWidth;
@@ -21,7 +24,74 @@ public unsafe partial struct ImFontAtlas
         public ImVector Fonts;
         public ImVector CustomRects;
         public ImVector ConfigData;
-        public fixed int CustomRectIds[1];
+        public Vector4 TexUvLines_0;
+        public Vector4 TexUvLines_1;
+        public Vector4 TexUvLines_2;
+        public Vector4 TexUvLines_3;
+        public Vector4 TexUvLines_4;
+        public Vector4 TexUvLines_5;
+        public Vector4 TexUvLines_6;
+        public Vector4 TexUvLines_7;
+        public Vector4 TexUvLines_8;
+        public Vector4 TexUvLines_9;
+        public Vector4 TexUvLines_10;
+        public Vector4 TexUvLines_11;
+        public Vector4 TexUvLines_12;
+        public Vector4 TexUvLines_13;
+        public Vector4 TexUvLines_14;
+        public Vector4 TexUvLines_15;
+        public Vector4 TexUvLines_16;
+        public Vector4 TexUvLines_17;
+        public Vector4 TexUvLines_18;
+        public Vector4 TexUvLines_19;
+        public Vector4 TexUvLines_20;
+        public Vector4 TexUvLines_21;
+        public Vector4 TexUvLines_22;
+        public Vector4 TexUvLines_23;
+        public Vector4 TexUvLines_24;
+        public Vector4 TexUvLines_25;
+        public Vector4 TexUvLines_26;
+        public Vector4 TexUvLines_27;
+        public Vector4 TexUvLines_28;
+        public Vector4 TexUvLines_29;
+        public Vector4 TexUvLines_30;
+        public Vector4 TexUvLines_31;
+        public Vector4 TexUvLines_32;
+        public Vector4 TexUvLines_33;
+        public Vector4 TexUvLines_34;
+        public Vector4 TexUvLines_35;
+        public Vector4 TexUvLines_36;
+        public Vector4 TexUvLines_37;
+        public Vector4 TexUvLines_38;
+        public Vector4 TexUvLines_39;
+        public Vector4 TexUvLines_40;
+        public Vector4 TexUvLines_41;
+        public Vector4 TexUvLines_42;
+        public Vector4 TexUvLines_43;
+        public Vector4 TexUvLines_44;
+        public Vector4 TexUvLines_45;
+        public Vector4 TexUvLines_46;
+        public Vector4 TexUvLines_47;
+        public Vector4 TexUvLines_48;
+        public Vector4 TexUvLines_49;
+        public Vector4 TexUvLines_50;
+        public Vector4 TexUvLines_51;
+        public Vector4 TexUvLines_52;
+        public Vector4 TexUvLines_53;
+        public Vector4 TexUvLines_54;
+        public Vector4 TexUvLines_55;
+        public Vector4 TexUvLines_56;
+        public Vector4 TexUvLines_57;
+        public Vector4 TexUvLines_58;
+        public Vector4 TexUvLines_59;
+        public Vector4 TexUvLines_60;
+        public Vector4 TexUvLines_61;
+        public Vector4 TexUvLines_62;
+        public Vector4 TexUvLines_63;
+        public IntPtr* FontBuilderIO;
+        public uint FontBuilderFlags;
+        public int PackIdMouseCursors;
+        public int PackIdLines;
     }
     public unsafe partial struct ImFontAtlasPtr
     {
@@ -31,11 +101,14 @@ public unsafe partial struct ImFontAtlasPtr
         public static implicit operator ImFontAtlasPtr(ImFontAtlas* nativePtr) => new ImFontAtlasPtr(nativePtr);
         public static implicit operator ImFontAtlas* (ImFontAtlasPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImFontAtlasPtr(IntPtr nativePtr) => new ImFontAtlasPtr(nativePtr);
-        public ref bool Locked => ref Unsafe.AsRef<bool>(&NativePtr->Locked);
         public ref ImFontAtlasFlags Flags => ref Unsafe.AsRef<ImFontAtlasFlags>(&NativePtr->Flags);
         public ref IntPtr TexID => ref Unsafe.AsRef<IntPtr>(&NativePtr->TexID);
         public ref int TexDesiredWidth => ref Unsafe.AsRef<int>(&NativePtr->TexDesiredWidth);
         public ref int TexGlyphPadding => ref Unsafe.AsRef<int>(&NativePtr->TexGlyphPadding);
+        public ref bool Locked => ref Unsafe.AsRef<bool>(&NativePtr->Locked);
+        public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
+        public ref bool TexReady => ref Unsafe.AsRef<bool>(&NativePtr->TexReady);
+        public ref bool TexPixelsUseColors => ref Unsafe.AsRef<bool>(&NativePtr->TexPixelsUseColors);
         public IntPtr TexPixelsAlpha8 { get => (IntPtr)NativePtr->TexPixelsAlpha8; set => NativePtr->TexPixelsAlpha8 = (byte*)value; }
         public IntPtr TexPixelsRGBA32 { get => (IntPtr)NativePtr->TexPixelsRGBA32; set => NativePtr->TexPixelsRGBA32 = (uint*)value; }
         public ref int TexWidth => ref Unsafe.AsRef<int>(&NativePtr->TexWidth);
@@ -43,45 +116,80 @@ public unsafe partial struct ImFontAtlasPtr
         public ref Vector2 TexUvScale => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvScale);
         public ref Vector2 TexUvWhitePixel => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvWhitePixel);
         public ImVector<ImFontPtr> Fonts => new ImVector<ImFontPtr>(NativePtr->Fonts);
-        public ImVector<CustomRect> CustomRects => new ImVector<CustomRect>(NativePtr->CustomRects);
+        public ImPtrVector<ImFontAtlasCustomRectPtr> CustomRects => new ImPtrVector<ImFontAtlasCustomRectPtr>(NativePtr->CustomRects, Unsafe.SizeOf<ImFontAtlasCustomRect>());
         public ImPtrVector<ImFontConfigPtr> ConfigData => new ImPtrVector<ImFontConfigPtr>(NativePtr->ConfigData, Unsafe.SizeOf<ImFontConfig>());
-        public RangeAccessor<int> CustomRectIds => new RangeAccessor<int>(NativePtr->CustomRectIds, 1);
+        public RangeAccessor<Vector4> TexUvLines => new RangeAccessor<Vector4>(&NativePtr->TexUvLines_0, 64);
+        public IntPtr FontBuilderIO { get => (IntPtr)NativePtr->FontBuilderIO; set => NativePtr->FontBuilderIO = (IntPtr*)value; }
+        public ref uint FontBuilderFlags => ref Unsafe.AsRef<uint>(&NativePtr->FontBuilderFlags);
+        public ref int PackIdMouseCursors => ref Unsafe.AsRef<int>(&NativePtr->PackIdMouseCursors);
+        public ref int PackIdLines => ref Unsafe.AsRef<int>(&NativePtr->PackIdLines);
         public int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x)
         {
             ImFont* native_font = font.NativePtr;
             Vector2 offset = new Vector2();
-            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, native_font, id, width, height, advance_x, offset);
+            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph((ImFontAtlas*)(NativePtr), native_font, id, width, height, advance_x, offset);
             return ret;
         }
         public int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x, Vector2 offset)
         {
             ImFont* native_font = font.NativePtr;
-            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, native_font, id, width, height, advance_x, offset);
+            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph((ImFontAtlas*)(NativePtr), native_font, id, width, height, advance_x, offset);
             return ret;
         }
-        public int AddCustomRectRegular(uint id, int width, int height)
+        public int AddCustomRectRegular(int width, int height)
         {
-            int ret = ImGuiNative.ImFontAtlas_AddCustomRectRegular(NativePtr, id, width, height);
+            int ret = ImGuiNative.ImFontAtlas_AddCustomRectRegular((ImFontAtlas*)(NativePtr), width, height);
             return ret;
         }
         public ImFontPtr AddFont(ImFontConfigPtr font_cfg)
         {
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFont(NativePtr, native_font_cfg);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFont((ImFontAtlas*)(NativePtr), native_font_cfg);
             return new ImFontPtr(ret);
         }
         public ImFontPtr AddFontDefault()
         {
             ImFontConfig* font_cfg = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, font_cfg);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault((ImFontAtlas*)(NativePtr), font_cfg);
             return new ImFontPtr(ret);
         }
         public ImFontPtr AddFontDefault(ImFontConfigPtr font_cfg)
         {
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, native_font_cfg);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault((ImFontAtlas*)(NativePtr), native_font_cfg);
             return new ImFontPtr(ret);
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public ImFontPtr AddFontFromFileTTF(ReadOnlySpan<char> filename, float size_pixels)
+        {
+            byte* native_filename;
+            int filename_byteCount = 0;
+            if (filename != null)
+            {
+                filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                if (filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_filename = Util.Allocate(filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                    native_filename = native_filename_stackBytes;
+                }
+                int native_filename_offset = Util.GetUtf8(filename, native_filename, filename_byteCount);
+                native_filename[native_filename_offset] = 0;
+            }
+            else { native_filename = null; }
+            ImFontConfig* font_cfg = null;
+            ushort* glyph_ranges = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF((ImFontAtlas*)(NativePtr), native_filename, size_pixels, font_cfg, glyph_ranges);
+            if (filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_filename);
+            }
+            return new ImFontPtr(ret);
+        }
+#endif
         public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels)
         {
             byte* native_filename;
@@ -104,13 +212,44 @@ public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels)
             else { native_filename = null; }
             ImFontConfig* font_cfg = null;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF((ImFontAtlas*)(NativePtr), native_filename, size_pixels, font_cfg, glyph_ranges);
             if (filename_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_filename);
             }
             return new ImFontPtr(ret);
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public ImFontPtr AddFontFromFileTTF(ReadOnlySpan<char> filename, float size_pixels, ImFontConfigPtr font_cfg)
+        {
+            byte* native_filename;
+            int filename_byteCount = 0;
+            if (filename != null)
+            {
+                filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                if (filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_filename = Util.Allocate(filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                    native_filename = native_filename_stackBytes;
+                }
+                int native_filename_offset = Util.GetUtf8(filename, native_filename, filename_byteCount);
+                native_filename[native_filename_offset] = 0;
+            }
+            else { native_filename = null; }
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ushort* glyph_ranges = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF((ImFontAtlas*)(NativePtr), native_filename, size_pixels, native_font_cfg, glyph_ranges);
+            if (filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_filename);
+            }
+            return new ImFontPtr(ret);
+        }
+#endif
         public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg)
         {
             byte* native_filename;
@@ -133,13 +272,44 @@ public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontCo
             else { native_filename = null; }
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, native_font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF((ImFontAtlas*)(NativePtr), native_filename, size_pixels, native_font_cfg, glyph_ranges);
+            if (filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_filename);
+            }
+            return new ImFontPtr(ret);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public ImFontPtr AddFontFromFileTTF(ReadOnlySpan<char> filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
+        {
+            byte* native_filename;
+            int filename_byteCount = 0;
+            if (filename != null)
+            {
+                filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                if (filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_filename = Util.Allocate(filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                    native_filename = native_filename_stackBytes;
+                }
+                int native_filename_offset = Util.GetUtf8(filename, native_filename, filename_byteCount);
+                native_filename[native_filename_offset] = 0;
+            }
+            else { native_filename = null; }
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF((ImFontAtlas*)(NativePtr), native_filename, size_pixels, native_font_cfg, native_glyph_ranges);
             if (filename_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_filename);
             }
             return new ImFontPtr(ret);
         }
+#endif
         public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
         {
             byte* native_filename;
@@ -162,13 +332,44 @@ public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontCo
             else { native_filename = null; }
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, native_font_cfg, native_glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF((ImFontAtlas*)(NativePtr), native_filename, size_pixels, native_font_cfg, native_glyph_ranges);
             if (filename_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_filename);
             }
             return new ImFontPtr(ret);
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public ImFontPtr AddFontFromMemoryCompressedBase85TTF(ReadOnlySpan<char> compressed_font_data_base85, float size_pixels)
+        {
+            byte* native_compressed_font_data_base85;
+            int compressed_font_data_base85_byteCount = 0;
+            if (compressed_font_data_base85 != null)
+            {
+                compressed_font_data_base85_byteCount = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
+                if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_compressed_font_data_base85 = Util.Allocate(compressed_font_data_base85_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_compressed_font_data_base85_stackBytes = stackalloc byte[compressed_font_data_base85_byteCount + 1];
+                    native_compressed_font_data_base85 = native_compressed_font_data_base85_stackBytes;
+                }
+                int native_compressed_font_data_base85_offset = Util.GetUtf8(compressed_font_data_base85, native_compressed_font_data_base85, compressed_font_data_base85_byteCount);
+                native_compressed_font_data_base85[native_compressed_font_data_base85_offset] = 0;
+            }
+            else { native_compressed_font_data_base85 = null; }
+            ImFontConfig* font_cfg = null;
+            ushort* glyph_ranges = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF((ImFontAtlas*)(NativePtr), native_compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
+            if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_compressed_font_data_base85);
+            }
+            return new ImFontPtr(ret);
+        }
+#endif
         public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels)
         {
             byte* native_compressed_font_data_base85;
@@ -191,13 +392,44 @@ public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_dat
             else { native_compressed_font_data_base85 = null; }
             ImFontConfig* font_cfg = null;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, native_compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF((ImFontAtlas*)(NativePtr), native_compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
             if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_compressed_font_data_base85);
             }
             return new ImFontPtr(ret);
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public ImFontPtr AddFontFromMemoryCompressedBase85TTF(ReadOnlySpan<char> compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg)
+        {
+            byte* native_compressed_font_data_base85;
+            int compressed_font_data_base85_byteCount = 0;
+            if (compressed_font_data_base85 != null)
+            {
+                compressed_font_data_base85_byteCount = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
+                if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_compressed_font_data_base85 = Util.Allocate(compressed_font_data_base85_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_compressed_font_data_base85_stackBytes = stackalloc byte[compressed_font_data_base85_byteCount + 1];
+                    native_compressed_font_data_base85 = native_compressed_font_data_base85_stackBytes;
+                }
+                int native_compressed_font_data_base85_offset = Util.GetUtf8(compressed_font_data_base85, native_compressed_font_data_base85, compressed_font_data_base85_byteCount);
+                native_compressed_font_data_base85[native_compressed_font_data_base85_offset] = 0;
+            }
+            else { native_compressed_font_data_base85 = null; }
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ushort* glyph_ranges = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF((ImFontAtlas*)(NativePtr), native_compressed_font_data_base85, size_pixels, native_font_cfg, glyph_ranges);
+            if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_compressed_font_data_base85);
+            }
+            return new ImFontPtr(ret);
+        }
+#endif
         public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg)
         {
             byte* native_compressed_font_data_base85;
@@ -220,13 +452,44 @@ public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_dat
             else { native_compressed_font_data_base85 = null; }
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, native_compressed_font_data_base85, size_pixels, native_font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF((ImFontAtlas*)(NativePtr), native_compressed_font_data_base85, size_pixels, native_font_cfg, glyph_ranges);
+            if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_compressed_font_data_base85);
+            }
+            return new ImFontPtr(ret);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public ImFontPtr AddFontFromMemoryCompressedBase85TTF(ReadOnlySpan<char> compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
+        {
+            byte* native_compressed_font_data_base85;
+            int compressed_font_data_base85_byteCount = 0;
+            if (compressed_font_data_base85 != null)
+            {
+                compressed_font_data_base85_byteCount = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
+                if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_compressed_font_data_base85 = Util.Allocate(compressed_font_data_base85_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_compressed_font_data_base85_stackBytes = stackalloc byte[compressed_font_data_base85_byteCount + 1];
+                    native_compressed_font_data_base85 = native_compressed_font_data_base85_stackBytes;
+                }
+                int native_compressed_font_data_base85_offset = Util.GetUtf8(compressed_font_data_base85, native_compressed_font_data_base85, compressed_font_data_base85_byteCount);
+                native_compressed_font_data_base85[native_compressed_font_data_base85_offset] = 0;
+            }
+            else { native_compressed_font_data_base85 = null; }
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF((ImFontAtlas*)(NativePtr), native_compressed_font_data_base85, size_pixels, native_font_cfg, native_glyph_ranges);
             if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_compressed_font_data_base85);
             }
             return new ImFontPtr(ret);
         }
+#endif
         public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
         {
             byte* native_compressed_font_data_base85;
@@ -249,133 +512,145 @@ public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_dat
             else { native_compressed_font_data_base85 = null; }
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, native_compressed_font_data_base85, size_pixels, native_font_cfg, native_glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF((ImFontAtlas*)(NativePtr), native_compressed_font_data_base85, size_pixels, native_font_cfg, native_glyph_ranges);
             if (compressed_font_data_base85_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_compressed_font_data_base85);
             }
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels)
+        public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_size, float size_pixels)
         {
             void* native_compressed_font_data = (void*)compressed_font_data.ToPointer();
             ImFontConfig* font_cfg = null;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, native_compressed_font_data, compressed_font_size, size_pixels, font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF((ImFontAtlas*)(NativePtr), native_compressed_font_data, compressed_font_data_size, size_pixels, font_cfg, glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels, ImFontConfigPtr font_cfg)
+        public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_size, float size_pixels, ImFontConfigPtr font_cfg)
         {
             void* native_compressed_font_data = (void*)compressed_font_data.ToPointer();
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, native_compressed_font_data, compressed_font_size, size_pixels, native_font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF((ImFontAtlas*)(NativePtr), native_compressed_font_data, compressed_font_data_size, size_pixels, native_font_cfg, glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
+        public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
         {
             void* native_compressed_font_data = (void*)compressed_font_data.ToPointer();
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, native_compressed_font_data, compressed_font_size, size_pixels, native_font_cfg, native_glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF((ImFontAtlas*)(NativePtr), native_compressed_font_data, compressed_font_data_size, size_pixels, native_font_cfg, native_glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_size, float size_pixels)
+        public ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_size, float size_pixels)
         {
             void* native_font_data = (void*)font_data.ToPointer();
             ImFontConfig* font_cfg = null;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, native_font_data, font_size, size_pixels, font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF((ImFontAtlas*)(NativePtr), native_font_data, font_data_size, size_pixels, font_cfg, glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_size, float size_pixels, ImFontConfigPtr font_cfg)
+        public ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_size, float size_pixels, ImFontConfigPtr font_cfg)
         {
             void* native_font_data = (void*)font_data.ToPointer();
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, native_font_data, font_size, size_pixels, native_font_cfg, glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF((ImFontAtlas*)(NativePtr), native_font_data, font_data_size, size_pixels, native_font_cfg, glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
+        public ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
         {
             void* native_font_data = (void*)font_data.ToPointer();
             ImFontConfig* native_font_cfg = font_cfg.NativePtr;
             ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, native_font_data, font_size, size_pixels, native_font_cfg, native_glyph_ranges);
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF((ImFontAtlas*)(NativePtr), native_font_data, font_data_size, size_pixels, native_font_cfg, native_glyph_ranges);
             return new ImFontPtr(ret);
         }
         public bool Build()
         {
-            byte ret = ImGuiNative.ImFontAtlas_Build(NativePtr);
+            byte ret = ImGuiNative.ImFontAtlas_Build((ImFontAtlas*)(NativePtr));
             return ret != 0;
         }
-        public void CalcCustomRectUV(ref CustomRect rect, out Vector2 out_uv_min, out Vector2 out_uv_max)
+        public void CalcCustomRectUV(ImFontAtlasCustomRectPtr rect, out Vector2 out_uv_min, out Vector2 out_uv_max)
         {
-            fixed (CustomRect* native_rect = &rect)
+            ImFontAtlasCustomRect* native_rect = rect.NativePtr;
+            fixed (Vector2* native_out_uv_min = &out_uv_min)
             {
-                fixed (Vector2* native_out_uv_min = &out_uv_min)
+                fixed (Vector2* native_out_uv_max = &out_uv_max)
                 {
-                    fixed (Vector2* native_out_uv_max = &out_uv_max)
-                    {
-                        ImGuiNative.ImFontAtlas_CalcCustomRectUV(NativePtr, native_rect, native_out_uv_min, native_out_uv_max);
-                    }
+                    ImGuiNative.ImFontAtlas_CalcCustomRectUV((ImFontAtlas*)(NativePtr), native_rect, native_out_uv_min, native_out_uv_max);
                 }
             }
         }
         public void Clear()
         {
-            ImGuiNative.ImFontAtlas_Clear(NativePtr);
+            ImGuiNative.ImFontAtlas_Clear((ImFontAtlas*)(NativePtr));
         }
         public void ClearFonts()
         {
-            ImGuiNative.ImFontAtlas_ClearFonts(NativePtr);
+            ImGuiNative.ImFontAtlas_ClearFonts((ImFontAtlas*)(NativePtr));
         }
         public void ClearInputData()
         {
-            ImGuiNative.ImFontAtlas_ClearInputData(NativePtr);
+            ImGuiNative.ImFontAtlas_ClearInputData((ImFontAtlas*)(NativePtr));
         }
         public void ClearTexData()
         {
-            ImGuiNative.ImFontAtlas_ClearTexData(NativePtr);
+            ImGuiNative.ImFontAtlas_ClearTexData((ImFontAtlas*)(NativePtr));
         }
-        public CustomRect* GetCustomRectByIndex(int index)
+        public void Destroy()
         {
-            CustomRect* ret = ImGuiNative.ImFontAtlas_GetCustomRectByIndex(NativePtr, index);
-            return ret;
+            ImGuiNative.ImFontAtlas_destroy((ImFontAtlas*)(NativePtr));
+        }
+        public ImFontAtlasCustomRectPtr GetCustomRectByIndex(int index)
+        {
+            ImFontAtlasCustomRect* ret = ImGuiNative.ImFontAtlas_GetCustomRectByIndex((ImFontAtlas*)(NativePtr), index);
+            return new ImFontAtlasCustomRectPtr(ret);
         }
         public IntPtr GetGlyphRangesChineseFull()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesChineseSimplifiedCommon()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesCyrillic()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesDefault()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesDefault((ImFontAtlas*)(NativePtr));
+            return (IntPtr)ret;
+        }
+        public IntPtr GetGlyphRangesGreek()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesGreek((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesJapanese()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesKorean()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesKorean((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesThai()
         {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesThai(NativePtr);
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesThai((ImFontAtlas*)(NativePtr));
+            return (IntPtr)ret;
+        }
+        public IntPtr GetGlyphRangesVietnamese()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesVietnamese((ImFontAtlas*)(NativePtr));
             return (IntPtr)ret;
         }
         public bool GetMouseCursorTexData(ImGuiMouseCursor cursor, out Vector2 out_offset, out Vector2 out_size, out Vector2 out_uv_border, out Vector2 out_uv_fill)
@@ -388,7 +663,7 @@ public bool GetMouseCursorTexData(ImGuiMouseCursor cursor, out Vector2 out_offse
                     {
                         fixed (Vector2* native_out_uv_fill = &out_uv_fill)
                         {
-                            byte ret = ImGuiNative.ImFontAtlas_GetMouseCursorTexData(NativePtr, cursor, native_out_offset, native_out_size, native_out_uv_border, native_out_uv_fill);
+                            byte ret = ImGuiNative.ImFontAtlas_GetMouseCursorTexData((ImFontAtlas*)(NativePtr), cursor, native_out_offset, native_out_size, native_out_uv_border, native_out_uv_fill);
                             return ret != 0;
                         }
                     }
@@ -404,7 +679,7 @@ public void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int
                 {
                     fixed (int* native_out_height = &out_height)
                     {
-                        ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, native_out_pixels, native_out_width, native_out_height, out_bytes_per_pixel);
+                        ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, out_bytes_per_pixel);
                     }
                 }
             }
@@ -419,7 +694,37 @@ public void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int
                     {
                         fixed (int* native_out_bytes_per_pixel = &out_bytes_per_pixel)
                         {
-                            ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, native_out_pixels, native_out_width, native_out_height, native_out_bytes_per_pixel);
+                            ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, native_out_bytes_per_pixel);
+                        }
+                    }
+                }
+            }
+        }
+        public void GetTexDataAsAlpha8(out IntPtr out_pixels, out int out_width, out int out_height)
+        {
+            int* out_bytes_per_pixel = null;
+            fixed (IntPtr* native_out_pixels = &out_pixels)
+            {
+                fixed (int* native_out_width = &out_width)
+                {
+                    fixed (int* native_out_height = &out_height)
+                    {
+                        ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, out_bytes_per_pixel);
+                    }
+                }
+            }
+        }
+        public void GetTexDataAsAlpha8(out IntPtr out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
+        {
+            fixed (IntPtr* native_out_pixels = &out_pixels)
+            {
+                fixed (int* native_out_width = &out_width)
+                {
+                    fixed (int* native_out_height = &out_height)
+                    {
+                        fixed (int* native_out_bytes_per_pixel = &out_bytes_per_pixel)
+                        {
+                            ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, native_out_bytes_per_pixel);
                         }
                     }
                 }
@@ -434,7 +739,7 @@ public void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int
                 {
                     fixed (int* native_out_height = &out_height)
                     {
-                        ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, native_out_pixels, native_out_width, native_out_height, out_bytes_per_pixel);
+                        ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, out_bytes_per_pixel);
                     }
                 }
             }
@@ -449,7 +754,37 @@ public void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int
                     {
                         fixed (int* native_out_bytes_per_pixel = &out_bytes_per_pixel)
                         {
-                            ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, native_out_pixels, native_out_width, native_out_height, native_out_bytes_per_pixel);
+                            ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, native_out_bytes_per_pixel);
+                        }
+                    }
+                }
+            }
+        }
+        public void GetTexDataAsRGBA32(out IntPtr out_pixels, out int out_width, out int out_height)
+        {
+            int* out_bytes_per_pixel = null;
+            fixed (IntPtr* native_out_pixels = &out_pixels)
+            {
+                fixed (int* native_out_width = &out_width)
+                {
+                    fixed (int* native_out_height = &out_height)
+                    {
+                        ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, out_bytes_per_pixel);
+                    }
+                }
+            }
+        }
+        public void GetTexDataAsRGBA32(out IntPtr out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
+        {
+            fixed (IntPtr* native_out_pixels = &out_pixels)
+            {
+                fixed (int* native_out_width = &out_width)
+                {
+                    fixed (int* native_out_height = &out_height)
+                    {
+                        fixed (int* native_out_bytes_per_pixel = &out_bytes_per_pixel)
+                        {
+                            ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32((ImFontAtlas*)(NativePtr), native_out_pixels, native_out_width, native_out_height, native_out_bytes_per_pixel);
                         }
                     }
                 }
@@ -457,12 +792,12 @@ public void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int
         }
         public bool IsBuilt()
         {
-            byte ret = ImGuiNative.ImFontAtlas_IsBuilt(NativePtr);
+            byte ret = ImGuiNative.ImFontAtlas_IsBuilt((ImFontAtlas*)(NativePtr));
             return ret != 0;
         }
         public void SetTexID(IntPtr id)
         {
-            ImGuiNative.ImFontAtlas_SetTexID(NativePtr, id);
+            ImGuiNative.ImFontAtlas_SetTexID((ImFontAtlas*)(NativePtr), id);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImFontAtlasCustomRect.gen.cs b/src/ImGui.NET/Generated/ImFontAtlasCustomRect.gen.cs
new file mode 100644
index 00000000..4a58bf48
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImFontAtlasCustomRect.gen.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImFontAtlasCustomRect
+    {
+        public ushort X;
+        public ushort Y;
+        public ushort Width;
+        public ushort Height;
+        public uint GlyphID;
+        public uint GlyphColored;
+        public float GlyphAdvanceX;
+        public Vector2 GlyphOffset;
+        public ImFont* Font;
+    }
+    public unsafe partial struct ImFontAtlasCustomRectPtr
+    {
+        public ImFontAtlasCustomRect* NativePtr { get; }
+        public ImFontAtlasCustomRectPtr(ImFontAtlasCustomRect* nativePtr) => NativePtr = nativePtr;
+        public ImFontAtlasCustomRectPtr(IntPtr nativePtr) => NativePtr = (ImFontAtlasCustomRect*)nativePtr;
+        public static implicit operator ImFontAtlasCustomRectPtr(ImFontAtlasCustomRect* nativePtr) => new ImFontAtlasCustomRectPtr(nativePtr);
+        public static implicit operator ImFontAtlasCustomRect* (ImFontAtlasCustomRectPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImFontAtlasCustomRectPtr(IntPtr nativePtr) => new ImFontAtlasCustomRectPtr(nativePtr);
+        public ref ushort X => ref Unsafe.AsRef<ushort>(&NativePtr->X);
+        public ref ushort Y => ref Unsafe.AsRef<ushort>(&NativePtr->Y);
+        public ref ushort Width => ref Unsafe.AsRef<ushort>(&NativePtr->Width);
+        public ref ushort Height => ref Unsafe.AsRef<ushort>(&NativePtr->Height);
+        public ref uint GlyphID => ref Unsafe.AsRef<uint>(&NativePtr->GlyphID);
+        public ref uint GlyphColored => ref Unsafe.AsRef<uint>(&NativePtr->GlyphColored);
+        public ref float GlyphAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphAdvanceX);
+        public ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphOffset);
+        public ImFontPtr Font => new ImFontPtr(NativePtr->Font);
+        public void Destroy()
+        {
+            ImGuiNative.ImFontAtlasCustomRect_destroy((ImFontAtlasCustomRect*)(NativePtr));
+        }
+        public bool IsPacked()
+        {
+            byte ret = ImGuiNative.ImFontAtlasCustomRect_IsPacked((ImFontAtlasCustomRect*)(NativePtr));
+            return ret != 0;
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImFontAtlasFlags.gen.cs b/src/ImGui.NET/Generated/ImFontAtlasFlags.gen.cs
index 1a6da21a..336f53e0 100644
--- a/src/ImGui.NET/Generated/ImFontAtlasFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImFontAtlasFlags.gen.cs
@@ -4,7 +4,8 @@ namespace ImGuiNET
     public enum ImFontAtlasFlags
     {
         None = 0,
-        NoPowerOfTwoHeight = 1 << 0,
-        NoMouseCursors = 1 << 1,
+        NoPowerOfTwoHeight = 1,
+        NoMouseCursors = 2,
+        NoBakedLines = 4,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImFontConfig.gen.cs b/src/ImGui.NET/Generated/ImFontConfig.gen.cs
index 9a55b828..46e785ba 100644
--- a/src/ImGui.NET/Generated/ImFontConfig.gen.cs
+++ b/src/ImGui.NET/Generated/ImFontConfig.gen.cs
@@ -21,8 +21,10 @@ public unsafe partial struct ImFontConfig
         public float GlyphMinAdvanceX;
         public float GlyphMaxAdvanceX;
         public byte MergeMode;
-        public uint RasterizerFlags;
+        public uint FontBuilderFlags;
         public float RasterizerMultiply;
+        public float RasterizerDensity;
+        public ushort EllipsisChar;
         public fixed byte Name[40];
         public ImFont* DstFont;
     }
@@ -48,9 +50,15 @@ public unsafe partial struct ImFontConfigPtr
         public ref float GlyphMinAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphMinAdvanceX);
         public ref float GlyphMaxAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphMaxAdvanceX);
         public ref bool MergeMode => ref Unsafe.AsRef<bool>(&NativePtr->MergeMode);
-        public ref uint RasterizerFlags => ref Unsafe.AsRef<uint>(&NativePtr->RasterizerFlags);
+        public ref uint FontBuilderFlags => ref Unsafe.AsRef<uint>(&NativePtr->FontBuilderFlags);
         public ref float RasterizerMultiply => ref Unsafe.AsRef<float>(&NativePtr->RasterizerMultiply);
+        public ref float RasterizerDensity => ref Unsafe.AsRef<float>(&NativePtr->RasterizerDensity);
+        public ref ushort EllipsisChar => ref Unsafe.AsRef<ushort>(&NativePtr->EllipsisChar);
         public RangeAccessor<byte> Name => new RangeAccessor<byte>(NativePtr->Name, 40);
         public ImFontPtr DstFont => new ImFontPtr(NativePtr->DstFont);
+        public void Destroy()
+        {
+            ImGuiNative.ImFontConfig_destroy((ImFontConfig*)(NativePtr));
+        }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImFontGlyph.gen.cs b/src/ImGui.NET/Generated/ImFontGlyph.gen.cs
index f0c4e8ef..8a78d6f3 100644
--- a/src/ImGui.NET/Generated/ImFontGlyph.gen.cs
+++ b/src/ImGui.NET/Generated/ImFontGlyph.gen.cs
@@ -7,7 +7,9 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImFontGlyph
     {
-        public ushort Codepoint;
+        public uint Colored;
+        public uint Visible;
+        public uint Codepoint;
         public float AdvanceX;
         public float X0;
         public float Y0;
@@ -26,7 +28,9 @@ public unsafe partial struct ImFontGlyphPtr
         public static implicit operator ImFontGlyphPtr(ImFontGlyph* nativePtr) => new ImFontGlyphPtr(nativePtr);
         public static implicit operator ImFontGlyph* (ImFontGlyphPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImFontGlyphPtr(IntPtr nativePtr) => new ImFontGlyphPtr(nativePtr);
-        public ref ushort Codepoint => ref Unsafe.AsRef<ushort>(&NativePtr->Codepoint);
+        public ref uint Colored => ref Unsafe.AsRef<uint>(&NativePtr->Colored);
+        public ref uint Visible => ref Unsafe.AsRef<uint>(&NativePtr->Visible);
+        public ref uint Codepoint => ref Unsafe.AsRef<uint>(&NativePtr->Codepoint);
         public ref float AdvanceX => ref Unsafe.AsRef<float>(&NativePtr->AdvanceX);
         public ref float X0 => ref Unsafe.AsRef<float>(&NativePtr->X0);
         public ref float Y0 => ref Unsafe.AsRef<float>(&NativePtr->Y0);
diff --git a/src/ImGui.NET/Generated/ImFontGlyphRangesBuilder.gen.cs b/src/ImGui.NET/Generated/ImFontGlyphRangesBuilder.gen.cs
index a839d524..4a0cb220 100644
--- a/src/ImGui.NET/Generated/ImFontGlyphRangesBuilder.gen.cs
+++ b/src/ImGui.NET/Generated/ImFontGlyphRangesBuilder.gen.cs
@@ -17,16 +17,44 @@ public unsafe partial struct ImFontGlyphRangesBuilderPtr
         public static implicit operator ImFontGlyphRangesBuilderPtr(ImFontGlyphRangesBuilder* nativePtr) => new ImFontGlyphRangesBuilderPtr(nativePtr);
         public static implicit operator ImFontGlyphRangesBuilder* (ImFontGlyphRangesBuilderPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImFontGlyphRangesBuilderPtr(IntPtr nativePtr) => new ImFontGlyphRangesBuilderPtr(nativePtr);
-        public ImVector<int> UsedChars => new ImVector<int>(NativePtr->UsedChars);
+        public ImVector<uint> UsedChars => new ImVector<uint>(NativePtr->UsedChars);
         public void AddChar(ushort c)
         {
-            ImGuiNative.ImFontGlyphRangesBuilder_AddChar(NativePtr, c);
+            ImGuiNative.ImFontGlyphRangesBuilder_AddChar((ImFontGlyphRangesBuilder*)(NativePtr), c);
         }
         public void AddRanges(IntPtr ranges)
         {
             ushort* native_ranges = (ushort*)ranges.ToPointer();
-            ImGuiNative.ImFontGlyphRangesBuilder_AddRanges(NativePtr, native_ranges);
+            ImGuiNative.ImFontGlyphRangesBuilder_AddRanges((ImFontGlyphRangesBuilder*)(NativePtr), native_ranges);
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void AddText(ReadOnlySpan<char> text)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.ImFontGlyphRangesBuilder_AddText((ImFontGlyphRangesBuilder*)(NativePtr), native_text, native_text+text_byteCount);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#endif
         public void AddText(string text)
         {
             byte* native_text;
@@ -47,8 +75,7 @@ public void AddText(string text)
                 native_text[native_text_offset] = 0;
             }
             else { native_text = null; }
-            byte* native_text_end = null;
-            ImGuiNative.ImFontGlyphRangesBuilder_AddText(NativePtr, native_text, native_text_end);
+            ImGuiNative.ImFontGlyphRangesBuilder_AddText((ImFontGlyphRangesBuilder*)(NativePtr), native_text, native_text+text_byteCount);
             if (text_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_text);
@@ -58,17 +85,25 @@ public void BuildRanges(out ImVector out_ranges)
         {
             fixed (ImVector* native_out_ranges = &out_ranges)
             {
-                ImGuiNative.ImFontGlyphRangesBuilder_BuildRanges(NativePtr, native_out_ranges);
+                ImGuiNative.ImFontGlyphRangesBuilder_BuildRanges((ImFontGlyphRangesBuilder*)(NativePtr), native_out_ranges);
             }
         }
-        public bool GetBit(int n)
+        public void Clear()
+        {
+            ImGuiNative.ImFontGlyphRangesBuilder_Clear((ImFontGlyphRangesBuilder*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImFontGlyphRangesBuilder_destroy((ImFontGlyphRangesBuilder*)(NativePtr));
+        }
+        public bool GetBit(uint n)
         {
-            byte ret = ImGuiNative.ImFontGlyphRangesBuilder_GetBit(NativePtr, n);
+            byte ret = ImGuiNative.ImFontGlyphRangesBuilder_GetBit((ImFontGlyphRangesBuilder*)(NativePtr), n);
             return ret != 0;
         }
-        public void SetBit(int n)
+        public void SetBit(uint n)
         {
-            ImGuiNative.ImFontGlyphRangesBuilder_SetBit(NativePtr, n);
+            ImGuiNative.ImFontGlyphRangesBuilder_SetBit((ImFontGlyphRangesBuilder*)(NativePtr), n);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGui.gen.cs b/src/ImGui.NET/Generated/ImGui.gen.cs
index a3673b97..94bce8d0 100644
--- a/src/ImGui.NET/Generated/ImGui.gen.cs
+++ b/src/ImGui.NET/Generated/ImGui.gen.cs
@@ -7,6 +7,36 @@ namespace ImGuiNET
 {
     public static unsafe partial class ImGui
     {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImGuiPayloadPtr AcceptDragDropPayload(ReadOnlySpan<char> type)
+        {
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
+            {
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_type = Util.Allocate(type_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
+                }
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
+            }
+            else { native_type = null; }
+            ImGuiDragDropFlags flags = (ImGuiDragDropFlags)0;
+            ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(native_type, flags);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_type);
+            }
+            return new ImGuiPayloadPtr(ret);
+        }
+#endif
         public static ImGuiPayloadPtr AcceptDragDropPayload(string type)
         {
             byte* native_type;
@@ -27,7 +57,35 @@ public static ImGuiPayloadPtr AcceptDragDropPayload(string type)
                 native_type[native_type_offset] = 0;
             }
             else { native_type = null; }
-            ImGuiDragDropFlags flags = 0;
+            ImGuiDragDropFlags flags = (ImGuiDragDropFlags)0;
+            ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(native_type, flags);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_type);
+            }
+            return new ImGuiPayloadPtr(ret);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImGuiPayloadPtr AcceptDragDropPayload(ReadOnlySpan<char> type, ImGuiDragDropFlags flags)
+        {
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
+            {
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_type = Util.Allocate(type_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
+                }
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
+            }
+            else { native_type = null; }
             ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(native_type, flags);
             if (type_byteCount > Util.StackAllocationSizeLimit)
             {
@@ -35,6 +93,7 @@ public static ImGuiPayloadPtr AcceptDragDropPayload(string type)
             }
             return new ImGuiPayloadPtr(ret);
         }
+#endif
         public static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
         {
             byte* native_type;
@@ -66,6 +125,35 @@ public static void AlignTextToFramePadding()
         {
             ImGuiNative.igAlignTextToFramePadding();
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ArrowButton(ReadOnlySpan<char> str_id, ImGuiDir dir)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igArrowButton(native_str_id, dir);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
         public static bool ArrowButton(string str_id, ImGuiDir dir)
         {
             byte* native_str_id;
@@ -93,6 +181,37 @@ public static bool ArrowButton(string str_id, ImGuiDir dir)
             }
             return ret != 0;
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Begin(ReadOnlySpan<char> name)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte* p_open = null;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBegin(native_name, p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+            return ret != 0;
+        }
+#endif
         public static bool Begin(string name)
         {
             byte* native_name;
@@ -114,7 +233,7 @@ public static bool Begin(string name)
             }
             else { native_name = null; }
             byte* p_open = null;
-            ImGuiWindowFlags flags = 0;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
             byte ret = ImGuiNative.igBegin(native_name, p_open, flags);
             if (name_byteCount > Util.StackAllocationSizeLimit)
             {
@@ -122,6 +241,39 @@ public static bool Begin(string name)
             }
             return ret != 0;
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Begin(ReadOnlySpan<char> name, ref bool p_open)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBegin(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+            p_open = native_p_open_val != 0;
+            return ret != 0;
+        }
+#endif
         public static bool Begin(string name, ref bool p_open)
         {
             byte* native_name;
@@ -144,7 +296,38 @@ public static bool Begin(string name, ref bool p_open)
             else { native_name = null; }
             byte native_p_open_val = p_open ? (byte)1 : (byte)0;
             byte* native_p_open = &native_p_open_val;
-            ImGuiWindowFlags flags = 0;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBegin(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+            p_open = native_p_open_val != 0;
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Begin(ReadOnlySpan<char> name, ref bool p_open, ImGuiWindowFlags flags)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
             byte ret = ImGuiNative.igBegin(native_name, native_p_open, flags);
             if (name_byteCount > Util.StackAllocationSizeLimit)
             {
@@ -153,6 +336,7 @@ public static bool Begin(string name, ref bool p_open)
             p_open = native_p_open_val != 0;
             return ret != 0;
         }
+#endif
         public static bool Begin(string name, ref bool p_open, ImGuiWindowFlags flags)
         {
             byte* native_name;
@@ -183,7 +367,8 @@ public static bool Begin(string name, ref bool p_open, ImGuiWindowFlags flags)
             p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool BeginChild(string str_id)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginChild(ReadOnlySpan<char> str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -204,16 +389,17 @@ public static bool BeginChild(string str_id)
             }
             else { native_str_id = null; }
             Vector2 size = new Vector2();
-            byte border = 0;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChild(native_str_id, size, border, flags);
+            ImGuiChildFlags child_flags = (ImGuiChildFlags)0;
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginChild(string str_id, Vector2 size)
+#endif
+        public static bool BeginChild(string str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -233,16 +419,18 @@ public static bool BeginChild(string str_id, Vector2 size)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte border = 0;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChild(native_str_id, size, border, flags);
+            Vector2 size = new Vector2();
+            ImGuiChildFlags child_flags = (ImGuiChildFlags)0;
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginChild(string str_id, Vector2 size, bool border)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginChild(ReadOnlySpan<char> str_id, Vector2 size)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -262,16 +450,17 @@ public static bool BeginChild(string str_id, Vector2 size, bool border)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte native_border = border ? (byte)1 : (byte)0;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChild(native_str_id, size, native_border, flags);
+            ImGuiChildFlags child_flags = (ImGuiChildFlags)0;
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginChild(string str_id, Vector2 size, bool border, ImGuiWindowFlags flags)
+#endif
+        public static bool BeginChild(string str_id, Vector2 size)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -291,110 +480,315 @@ public static bool BeginChild(string str_id, Vector2 size, bool border, ImGuiWin
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte native_border = border ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igBeginChild(native_str_id, size, native_border, flags);
+            ImGuiChildFlags child_flags = (ImGuiChildFlags)0;
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginChild(uint id)
-        {
-            Vector2 size = new Vector2();
-            byte border = 0;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChildID(id, size, border, flags);
-            return ret != 0;
-        }
-        public static bool BeginChild(uint id, Vector2 size)
-        {
-            byte border = 0;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChildID(id, size, border, flags);
-            return ret != 0;
-        }
-        public static bool BeginChild(uint id, Vector2 size, bool border)
-        {
-            byte native_border = border ? (byte)1 : (byte)0;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChildID(id, size, native_border, flags);
-            return ret != 0;
-        }
-        public static bool BeginChild(uint id, Vector2 size, bool border, ImGuiWindowFlags flags)
-        {
-            byte native_border = border ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igBeginChildID(id, size, native_border, flags);
-            return ret != 0;
-        }
-        public static bool BeginChildFrame(uint id, Vector2 size)
-        {
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginChildFrame(id, size, flags);
-            return ret != 0;
-        }
-        public static bool BeginChildFrame(uint id, Vector2 size, ImGuiWindowFlags flags)
-        {
-            byte ret = ImGuiNative.igBeginChildFrame(id, size, flags);
-            return ret != 0;
-        }
-        public static bool BeginCombo(string label, string preview_value)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginChild(ReadOnlySpan<char> str_id, Vector2 size, ImGuiChildFlags child_flags)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_preview_value;
-            int preview_value_byteCount = 0;
-            if (preview_value != null)
+            else { native_str_id = null; }
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                preview_value_byteCount = Encoding.UTF8.GetByteCount(preview_value);
-                if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginChild(string str_id, Vector2 size, ImGuiChildFlags child_flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_preview_value = Util.Allocate(preview_value_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_preview_value_stackBytes = stackalloc byte[preview_value_byteCount + 1];
-                    native_preview_value = native_preview_value_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_preview_value_offset = Util.GetUtf8(preview_value, native_preview_value, preview_value_byteCount);
-                native_preview_value[native_preview_value_offset] = 0;
-            }
-            else { native_preview_value = null; }
-            ImGuiComboFlags flags = 0;
-            byte ret = ImGuiNative.igBeginCombo(native_label, native_preview_value, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_preview_value);
+                Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginCombo(string label, string preview_value, ImGuiComboFlags flags)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginChild(ReadOnlySpan<char> str_id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
-            {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginChild(string str_id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginChild_Str(native_str_id, size, child_flags, window_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+        public static bool BeginChild(uint id)
+        {
+            Vector2 size = new Vector2();
+            ImGuiChildFlags child_flags = (ImGuiChildFlags)0;
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
+            return ret != 0;
+        }
+        public static bool BeginChild(uint id, Vector2 size)
+        {
+            ImGuiChildFlags child_flags = (ImGuiChildFlags)0;
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
+            return ret != 0;
+        }
+        public static bool BeginChild(uint id, Vector2 size, ImGuiChildFlags child_flags)
+        {
+            ImGuiWindowFlags window_flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
+            return ret != 0;
+        }
+        public static bool BeginChild(uint id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
+        {
+            byte ret = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginCombo(ReadOnlySpan<char> label, ReadOnlySpan<char> preview_value)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_preview_value;
+            int preview_value_byteCount = 0;
+            if (preview_value != null)
+            {
+                preview_value_byteCount = Encoding.UTF8.GetByteCount(preview_value);
+                if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_preview_value = Util.Allocate(preview_value_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_preview_value_stackBytes = stackalloc byte[preview_value_byteCount + 1];
+                    native_preview_value = native_preview_value_stackBytes;
+                }
+                int native_preview_value_offset = Util.GetUtf8(preview_value, native_preview_value, preview_value_byteCount);
+                native_preview_value[native_preview_value_offset] = 0;
+            }
+            else { native_preview_value = null; }
+            ImGuiComboFlags flags = (ImGuiComboFlags)0;
+            byte ret = ImGuiNative.igBeginCombo(native_label, native_preview_value, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_preview_value);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginCombo(string label, string preview_value)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_preview_value;
+            int preview_value_byteCount = 0;
+            if (preview_value != null)
+            {
+                preview_value_byteCount = Encoding.UTF8.GetByteCount(preview_value);
+                if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_preview_value = Util.Allocate(preview_value_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_preview_value_stackBytes = stackalloc byte[preview_value_byteCount + 1];
+                    native_preview_value = native_preview_value_stackBytes;
+                }
+                int native_preview_value_offset = Util.GetUtf8(preview_value, native_preview_value, preview_value_byteCount);
+                native_preview_value[native_preview_value_offset] = 0;
+            }
+            else { native_preview_value = null; }
+            ImGuiComboFlags flags = (ImGuiComboFlags)0;
+            byte ret = ImGuiNative.igBeginCombo(native_label, native_preview_value, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_preview_value);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginCombo(ReadOnlySpan<char> label, ReadOnlySpan<char> preview_value, ImGuiComboFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_preview_value;
+            int preview_value_byteCount = 0;
+            if (preview_value != null)
+            {
+                preview_value_byteCount = Encoding.UTF8.GetByteCount(preview_value);
+                if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_preview_value = Util.Allocate(preview_value_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_preview_value_stackBytes = stackalloc byte[preview_value_byteCount + 1];
+                    native_preview_value = native_preview_value_stackBytes;
+                }
+                int native_preview_value_offset = Util.GetUtf8(preview_value, native_preview_value, preview_value_byteCount);
+                native_preview_value[native_preview_value_offset] = 0;
+            }
+            else { native_preview_value = null; }
+            byte ret = ImGuiNative.igBeginCombo(native_label, native_preview_value, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (preview_value_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_preview_value);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginCombo(string label, string preview_value, ImGuiComboFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_label = Util.Allocate(label_byteCount + 1);
@@ -437,9 +831,19 @@ public static bool BeginCombo(string label, string preview_value, ImGuiComboFlag
             }
             return ret != 0;
         }
+        public static void BeginDisabled()
+        {
+            byte disabled = 1;
+            ImGuiNative.igBeginDisabled(disabled);
+        }
+        public static void BeginDisabled(bool disabled)
+        {
+            byte native_disabled = disabled ? (byte)1 : (byte)0;
+            ImGuiNative.igBeginDisabled(native_disabled);
+        }
         public static bool BeginDragDropSource()
         {
-            ImGuiDragDropFlags flags = 0;
+            ImGuiDragDropFlags flags = (ImGuiDragDropFlags)0;
             byte ret = ImGuiNative.igBeginDragDropSource(flags);
             return ret != 0;
         }
@@ -457,12 +861,13 @@ public static void BeginGroup()
         {
             ImGuiNative.igBeginGroup();
         }
-        public static bool BeginMainMenuBar()
+        public static bool BeginItemTooltip()
         {
-            byte ret = ImGuiNative.igBeginMainMenuBar();
+            byte ret = ImGuiNative.igBeginItemTooltip();
             return ret != 0;
         }
-        public static bool BeginMenu(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginListBox(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -482,15 +887,16 @@ public static bool BeginMenu(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte enabled = 1;
-            byte ret = ImGuiNative.igBeginMenu(native_label, enabled);
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igBeginListBox(native_label, size);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static bool BeginMenu(string label, bool enabled)
+#endif
+        public static bool BeginListBox(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -510,40 +916,236 @@ public static bool BeginMenu(string label, bool enabled)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_enabled = enabled ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igBeginMenu(native_label, native_enabled);
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igBeginListBox(native_label, size);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static bool BeginMenuBar()
-        {
-            byte ret = ImGuiNative.igBeginMenuBar();
-            return ret != 0;
-        }
-        public static bool BeginPopup(string str_id)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginListBox(ReadOnlySpan<char> label, Vector2 size)
         {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImGuiNative.igBeginListBox(native_label, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginListBox(string label, Vector2 size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImGuiNative.igBeginListBox(native_label, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+        public static bool BeginMainMenuBar()
+        {
+            byte ret = ImGuiNative.igBeginMainMenuBar();
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginMenu(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte enabled = 1;
+            byte ret = ImGuiNative.igBeginMenu(native_label, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginMenu(string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte enabled = 1;
+            byte ret = ImGuiNative.igBeginMenu(native_label, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginMenu(ReadOnlySpan<char> label, bool enabled)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igBeginMenu(native_label, native_enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginMenu(string label, bool enabled)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igBeginMenu(native_label, native_enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+        public static bool BeginMenuBar()
+        {
+            byte ret = ImGuiNative.igBeginMenuBar();
+            return ret != 0;
+        }
+        public static ImGuiMultiSelectIOPtr BeginMultiSelect(ImGuiMultiSelectFlags flags)
+        {
+            int selection_size = -1;
+            int items_count = -1;
+            ImGuiMultiSelectIO* ret = ImGuiNative.igBeginMultiSelect(flags, selection_size, items_count);
+            return new ImGuiMultiSelectIOPtr(ret);
+        }
+        public static ImGuiMultiSelectIOPtr BeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size)
+        {
+            int items_count = -1;
+            ImGuiMultiSelectIO* ret = ImGuiNative.igBeginMultiSelect(flags, selection_size, items_count);
+            return new ImGuiMultiSelectIOPtr(ret);
+        }
+        public static ImGuiMultiSelectIOPtr BeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size, int items_count)
+        {
+            ImGuiMultiSelectIO* ret = ImGuiNative.igBeginMultiSelect(flags, selection_size, items_count);
+            return new ImGuiMultiSelectIOPtr(ret);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopup(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            ImGuiWindowFlags flags = 0;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
             byte ret = ImGuiNative.igBeginPopup(native_str_id, flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
@@ -551,7 +1153,8 @@ public static bool BeginPopup(string str_id)
             }
             return ret != 0;
         }
-        public static bool BeginPopup(string str_id, ImGuiWindowFlags flags)
+#endif
+        public static bool BeginPopup(string str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -571,6 +1174,7 @@ public static bool BeginPopup(string str_id, ImGuiWindowFlags flags)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
             byte ret = ImGuiNative.igBeginPopup(native_str_id, flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
@@ -578,14 +1182,8 @@ public static bool BeginPopup(string str_id, ImGuiWindowFlags flags)
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextItem()
-        {
-            byte* native_str_id = null;
-            int mouse_button = 1;
-            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, mouse_button);
-            return ret != 0;
-        }
-        public static bool BeginPopupContextItem(string str_id)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopup(ReadOnlySpan<char> str_id, ImGuiWindowFlags flags)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -605,15 +1203,15 @@ public static bool BeginPopupContextItem(string str_id)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            int mouse_button = 1;
-            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, mouse_button);
+            byte ret = ImGuiNative.igBeginPopup(native_str_id, flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextItem(string str_id, int mouse_button)
+#endif
+        public static bool BeginPopup(string str_id, ImGuiWindowFlags flags)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -633,21 +1231,22 @@ public static bool BeginPopupContextItem(string str_id, int mouse_button)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, mouse_button);
+            byte ret = ImGuiNative.igBeginPopup(native_str_id, flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextVoid()
+        public static bool BeginPopupContextItem()
         {
             byte* native_str_id = null;
-            int mouse_button = 1;
-            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, mouse_button);
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, popup_flags);
             return ret != 0;
         }
-        public static bool BeginPopupContextVoid(string str_id)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupContextItem(ReadOnlySpan<char> str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -667,15 +1266,16 @@ public static bool BeginPopupContextVoid(string str_id)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            int mouse_button = 1;
-            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, mouse_button);
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextVoid(string str_id, int mouse_button)
+#endif
+        public static bool BeginPopupContextItem(string str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -695,22 +1295,16 @@ public static bool BeginPopupContextVoid(string str_id, int mouse_button)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, mouse_button);
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextWindow()
-        {
-            byte* native_str_id = null;
-            int mouse_button = 1;
-            byte also_over_items = 1;
-            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, mouse_button, also_over_items);
-            return ret != 0;
-        }
-        public static bool BeginPopupContextWindow(string str_id)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupContextItem(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -730,16 +1324,15 @@ public static bool BeginPopupContextWindow(string str_id)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            int mouse_button = 1;
-            byte also_over_items = 1;
-            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, mouse_button, also_over_items);
+            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextWindow(string str_id, int mouse_button)
+#endif
+        public static bool BeginPopupContextItem(string str_id, ImGuiPopupFlags popup_flags)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -759,15 +1352,22 @@ public static bool BeginPopupContextWindow(string str_id, int mouse_button)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte also_over_items = 1;
-            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, mouse_button, also_over_items);
+            byte ret = ImGuiNative.igBeginPopupContextItem(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupContextWindow(string str_id, int mouse_button, bool also_over_items)
+        public static bool BeginPopupContextVoid()
+        {
+            byte* native_str_id = null;
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, popup_flags);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupContextVoid(ReadOnlySpan<char> str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -787,105 +1387,108 @@ public static bool BeginPopupContextWindow(string str_id, int mouse_button, bool
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte native_also_over_items = also_over_items ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, mouse_button, native_also_over_items);
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupModal(string name)
+#endif
+        public static bool BeginPopupContextVoid(string str_id)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_name = null; }
-            byte* p_open = null;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginPopupModal(native_name, p_open, flags);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginPopupModal(string name, ref bool p_open)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupContextVoid(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_name = null; }
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            ImGuiWindowFlags flags = 0;
-            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_str_id);
             }
-            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool BeginPopupModal(string name, ref bool p_open, ImGuiWindowFlags flags)
+#endif
+        public static bool BeginPopupContextVoid(string str_id, ImGuiPopupFlags popup_flags)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_name = null; }
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginPopupContextVoid(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_str_id);
             }
-            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool BeginTabBar(string str_id)
+        public static bool BeginPopupContextWindow()
+        {
+            byte* native_str_id = null;
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, popup_flags);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupContextWindow(ReadOnlySpan<char> str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -905,15 +1508,16 @@ public static bool BeginTabBar(string str_id)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            ImGuiTabBarFlags flags = 0;
-            byte ret = ImGuiNative.igBeginTabBar(native_str_id, flags);
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginTabBar(string str_id, ImGuiTabBarFlags flags)
+#endif
+        public static bool BeginPopupContextWindow(string str_id)
         {
             byte* native_str_id;
             int str_id_byteCount = 0;
@@ -933,248 +1537,372 @@ public static bool BeginTabBar(string str_id, ImGuiTabBarFlags flags)
                 native_str_id[native_str_id_offset] = 0;
             }
             else { native_str_id = null; }
-            byte ret = ImGuiNative.igBeginTabBar(native_str_id, flags);
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, popup_flags);
             if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginTabItem(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupContextWindow(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_label = null; }
-            byte* p_open = null;
-            ImGuiTabItemFlags flags = 0;
-            byte ret = ImGuiNative.igBeginTabItem(native_label, p_open, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool BeginTabItem(string label, ref bool p_open)
+#endif
+        public static bool BeginPopupContextWindow(string str_id, ImGuiPopupFlags popup_flags)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_label = null; }
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            ImGuiTabItemFlags flags = 0;
-            byte ret = ImGuiNative.igBeginTabItem(native_label, native_p_open, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginPopupContextWindow(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_str_id);
             }
-            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool BeginTabItem(string label, ref bool p_open, ImGuiTabItemFlags flags)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupModal(ReadOnlySpan<char> name)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            byte ret = ImGuiNative.igBeginTabItem(native_label, native_p_open, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            byte* p_open = null;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_name);
             }
-            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static void BeginTooltip()
-        {
-            ImGuiNative.igBeginTooltip();
-        }
-        public static void Bullet()
-        {
-            ImGuiNative.igBullet();
-        }
-        public static void BulletText(string fmt)
+#endif
+        public static bool BeginPopupModal(string name)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_fmt = null; }
-            ImGuiNative.igBulletText(native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            byte* p_open = null;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_fmt);
+                Util.Free(native_name);
             }
+            return ret != 0;
         }
-        public static bool Button(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupModal(ReadOnlySpan<char> name, ref bool p_open)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igButton(native_label, size);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_name);
             }
+            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool Button(string label, Vector2 size)
+#endif
+        public static bool BeginPopupModal(string name, ref bool p_open)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            byte ret = ImGuiNative.igButton(native_label, size);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiWindowFlags flags = (ImGuiWindowFlags)0;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_name);
             }
+            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static float CalcItemWidth()
-        {
-            float ret = ImGuiNative.igCalcItemWidth();
-            return ret;
-        }
-        public static Vector2 CalcTextSize(string text)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPopupModal(ReadOnlySpan<char> name, ref bool p_open, ImGuiWindowFlags flags)
         {
-            byte* native_text;
-            int text_byteCount = 0;
-            if (text != null)
-            {
-                text_byteCount = Encoding.UTF8.GetByteCount(text);
-                if (text_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_text = Util.Allocate(text_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
-                    native_text = native_text_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
-                native_text[native_text_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_text = null; }
-            byte* native_text_end = null;
-            byte hide_text_after_double_hash = 0;
-            float wrap_width = -1.0f;
-            Vector2 ret = ImGuiNative.igCalcTextSize(native_text, native_text_end, hide_text_after_double_hash, wrap_width);
-            if (text_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_text);
+                Util.Free(native_name);
             }
-            return ret;
+            p_open = native_p_open_val != 0;
+            return ret != 0;
+        }
+#endif
+        public static bool BeginPopupModal(string name, ref bool p_open, ImGuiWindowFlags flags)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+            p_open = native_p_open_val != 0;
+            return ret != 0;
         }
-        public static void CaptureKeyboardFromApp()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTabBar(ReadOnlySpan<char> str_id)
         {
-            byte want_capture_keyboard_value = 1;
-            ImGuiNative.igCaptureKeyboardFromApp(want_capture_keyboard_value);
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiTabBarFlags flags = (ImGuiTabBarFlags)0;
+            byte ret = ImGuiNative.igBeginTabBar(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
         }
-        public static void CaptureKeyboardFromApp(bool want_capture_keyboard_value)
+#endif
+        public static bool BeginTabBar(string str_id)
         {
-            byte native_want_capture_keyboard_value = want_capture_keyboard_value ? (byte)1 : (byte)0;
-            ImGuiNative.igCaptureKeyboardFromApp(native_want_capture_keyboard_value);
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiTabBarFlags flags = (ImGuiTabBarFlags)0;
+            byte ret = ImGuiNative.igBeginTabBar(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
         }
-        public static void CaptureMouseFromApp()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTabBar(ReadOnlySpan<char> str_id, ImGuiTabBarFlags flags)
         {
-            byte want_capture_mouse_value = 1;
-            ImGuiNative.igCaptureMouseFromApp(want_capture_mouse_value);
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginTabBar(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
         }
-        public static void CaptureMouseFromApp(bool want_capture_mouse_value)
+#endif
+        public static bool BeginTabBar(string str_id, ImGuiTabBarFlags flags)
         {
-            byte native_want_capture_mouse_value = want_capture_mouse_value ? (byte)1 : (byte)0;
-            ImGuiNative.igCaptureMouseFromApp(native_want_capture_mouse_value);
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginTabBar(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
         }
-        public static bool Checkbox(string label, ref bool v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTabItem(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1194,17 +1922,17 @@ public static bool Checkbox(string label, ref bool v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_v_val = v ? (byte)1 : (byte)0;
-            byte* native_v = &native_v_val;
-            byte ret = ImGuiNative.igCheckbox(native_label, native_v);
+            byte* p_open = null;
+            ImGuiTabItemFlags flags = (ImGuiTabItemFlags)0;
+            byte ret = ImGuiNative.igBeginTabItem(native_label, p_open, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
-            v = native_v_val != 0;
             return ret != 0;
         }
-        public static bool CheckboxFlags(string label, ref uint flags, uint flags_value)
+#endif
+        public static bool BeginTabItem(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1224,21 +1952,17 @@ public static bool CheckboxFlags(string label, ref uint flags, uint flags_value)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            fixed (uint* native_flags = &flags)
+            byte* p_open = null;
+            ImGuiTabItemFlags flags = (ImGuiTabItemFlags)0;
+            byte ret = ImGuiNative.igBeginTabItem(native_label, p_open, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igCheckboxFlags(native_label, native_flags, flags_value);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static void CloseCurrentPopup()
-        {
-            ImGuiNative.igCloseCurrentPopup();
-        }
-        public static bool CollapsingHeader(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTabItem(ReadOnlySpan<char> label, ref bool p_open)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1258,15 +1982,19 @@ public static bool CollapsingHeader(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiTreeNodeFlags flags = 0;
-            byte ret = ImGuiNative.igCollapsingHeader(native_label, flags);
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiTabItemFlags flags = (ImGuiTabItemFlags)0;
+            byte ret = ImGuiNative.igBeginTabItem(native_label, native_p_open, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
+            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool CollapsingHeader(string label, ImGuiTreeNodeFlags flags)
+#endif
+        public static bool BeginTabItem(string label, ref bool p_open)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1286,14 +2014,19 @@ public static bool CollapsingHeader(string label, ImGuiTreeNodeFlags flags)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte ret = ImGuiNative.igCollapsingHeader(native_label, flags);
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiTabItemFlags flags = (ImGuiTabItemFlags)0;
+            byte ret = ImGuiNative.igBeginTabItem(native_label, native_p_open, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
+            p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool CollapsingHeader(string label, ref bool p_open)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTabItem(ReadOnlySpan<char> label, ref bool p_open, ImGuiTabItemFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1315,8 +2048,7 @@ public static bool CollapsingHeader(string label, ref bool p_open)
             else { native_label = null; }
             byte native_p_open_val = p_open ? (byte)1 : (byte)0;
             byte* native_p_open = &native_p_open_val;
-            ImGuiTreeNodeFlags flags = 0;
-            byte ret = ImGuiNative.igCollapsingHeaderBoolPtr(native_label, native_p_open, flags);
+            byte ret = ImGuiNative.igBeginTabItem(native_label, native_p_open, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
@@ -1324,7 +2056,8 @@ public static bool CollapsingHeader(string label, ref bool p_open)
             p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool CollapsingHeader(string label, ref bool p_open, ImGuiTreeNodeFlags flags)
+#endif
+        public static bool BeginTabItem(string label, ref bool p_open, ImGuiTabItemFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1346,7 +2079,7 @@ public static bool CollapsingHeader(string label, ref bool p_open, ImGuiTreeNode
             else { native_label = null; }
             byte native_p_open_val = p_open ? (byte)1 : (byte)0;
             byte* native_p_open = &native_p_open_val;
-            byte ret = ImGuiNative.igCollapsingHeaderBoolPtr(native_label, native_p_open, flags);
+            byte ret = ImGuiNative.igBeginTabItem(native_label, native_p_open, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
@@ -1354,188 +2087,307 @@ public static bool CollapsingHeader(string label, ref bool p_open, ImGuiTreeNode
             p_open = native_p_open_val != 0;
             return ret != 0;
         }
-        public static bool ColorButton(string desc_id, Vector4 col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTable(ReadOnlySpan<char> str_id, int columns)
         {
-            byte* native_desc_id;
-            int desc_id_byteCount = 0;
-            if (desc_id != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
-                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
-                    native_desc_id = native_desc_id_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
-                native_desc_id[native_desc_id_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_desc_id = null; }
-            ImGuiColorEditFlags flags = 0;
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
-            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            ImGuiTableFlags flags = (ImGuiTableFlags)0;
+            Vector2 outer_size = new Vector2();
+            float inner_width = 0.0f;
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_desc_id);
+                Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags)
+#endif
+        public static bool BeginTable(string str_id, int columns)
         {
-            byte* native_desc_id;
-            int desc_id_byteCount = 0;
-            if (desc_id != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
-                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
-                    native_desc_id = native_desc_id_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
-                native_desc_id[native_desc_id_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_desc_id = null; }
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
-            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            ImGuiTableFlags flags = (ImGuiTableFlags)0;
+            Vector2 outer_size = new Vector2();
+            float inner_width = 0.0f;
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_desc_id);
+                Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTable(ReadOnlySpan<char> str_id, int columns, ImGuiTableFlags flags)
         {
-            byte* native_desc_id;
-            int desc_id_byteCount = 0;
-            if (desc_id != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
-                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
-                    native_desc_id = native_desc_id_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
-                native_desc_id[native_desc_id_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_desc_id = null; }
-            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
-            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            Vector2 outer_size = new Vector2();
+            float inner_width = 0.0f;
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_desc_id);
+                Util.Free(native_str_id);
             }
             return ret != 0;
         }
-        public static uint ColorConvertFloat4ToU32(Vector4 @in)
-        {
-            uint ret = ImGuiNative.igColorConvertFloat4ToU32(@in);
-            return ret;
-        }
-        public static void ColorConvertHSVtoRGB(float h, float s, float v, out float out_r, out float out_g, out float out_b)
+#endif
+        public static bool BeginTable(string str_id, int columns, ImGuiTableFlags flags)
         {
-            fixed (float* native_out_r = &out_r)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                fixed (float* native_out_g = &out_g)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    fixed (float* native_out_b = &out_b)
-                    {
-                        ImGuiNative.igColorConvertHSVtoRGB(h, s, v, native_out_r, native_out_g, native_out_b);
-                    }
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector2 outer_size = new Vector2();
+            float inner_width = 0.0f;
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
             }
+            return ret != 0;
         }
-        public static void ColorConvertRGBtoHSV(float r, float g, float b, out float out_h, out float out_s, out float out_v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTable(ReadOnlySpan<char> str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size)
         {
-            fixed (float* native_out_h = &out_h)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                fixed (float* native_out_s = &out_s)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    fixed (float* native_out_v = &out_v)
-                    {
-                        ImGuiNative.igColorConvertRGBtoHSV(r, g, b, native_out_h, native_out_s, native_out_v);
-                    }
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            float inner_width = 0.0f;
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
             }
+            return ret != 0;
         }
-        public static Vector4 ColorConvertU32ToFloat4(uint @in)
+#endif
+        public static bool BeginTable(string str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size)
         {
-            Vector4 ret = ImGuiNative.igColorConvertU32ToFloat4(@in);
-            return ret;
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            float inner_width = 0.0f;
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
         }
-        public static bool ColorEdit3(string label, ref Vector3 col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginTable(ReadOnlySpan<char> str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size, float inner_width)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_label = null; }
-            ImGuiColorEditFlags flags = 0;
-            fixed (Vector3* native_col = &col)
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorEdit3(native_label, native_col, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginTable(string str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size, float inner_width)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
-                return ret != 0;
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igBeginTable(native_str_id, columns, flags, outer_size, inner_width);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
             }
+            return ret != 0;
         }
-        public static bool ColorEdit3(string label, ref Vector3 col, ImGuiColorEditFlags flags)
+        public static bool BeginTooltip()
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte ret = ImGuiNative.igBeginTooltip();
+            return ret != 0;
+        }
+        public static void Bullet()
+        {
+            ImGuiNative.igBullet();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void BulletText(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_label = null; }
-            fixed (Vector3* native_col = &col)
+            else { native_fmt = null; }
+            ImGuiNative.igBulletText(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorEdit3(native_label, native_col, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void BulletText(string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
-                return ret != 0;
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igBulletText(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
         }
-        public static bool ColorEdit4(string label, ref Vector4 col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Button(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1555,18 +2407,16 @@ public static bool ColorEdit4(string label, ref Vector4 col)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiColorEditFlags flags = 0;
-            fixed (Vector4* native_col = &col)
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igButton(native_label, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorEdit4(native_label, native_col, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool ColorEdit4(string label, ref Vector4 col, ImGuiColorEditFlags flags)
+#endif
+        public static bool Button(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1586,17 +2436,16 @@ public static bool ColorEdit4(string label, ref Vector4 col, ImGuiColorEditFlags
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            fixed (Vector4* native_col = &col)
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igButton(native_label, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorEdit4(native_label, native_col, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool ColorPicker3(string label, ref Vector3 col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Button(ReadOnlySpan<char> label, Vector2 size)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1616,18 +2465,15 @@ public static bool ColorPicker3(string label, ref Vector3 col)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiColorEditFlags flags = 0;
-            fixed (Vector3* native_col = &col)
+            byte ret = ImGuiNative.igButton(native_label, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorPicker3(native_label, native_col, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool ColorPicker3(string label, ref Vector3 col, ImGuiColorEditFlags flags)
+#endif
+        public static bool Button(string label, Vector2 size)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1647,180 +2493,204 @@ public static bool ColorPicker3(string label, ref Vector3 col, ImGuiColorEditFla
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            fixed (Vector3* native_col = &col)
+            byte ret = ImGuiNative.igButton(native_label, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorPicker3(native_label, native_col, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool ColorPicker4(string label, ref Vector4 col)
+        public static float CalcItemWidth()
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            float ret = ImGuiNative.igCalcItemWidth();
+            return ret;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text)
+        {
+            Vector2 __retval;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
             }
-            else { native_label = null; }
-            ImGuiColorEditFlags flags = 0;
-            float* ref_col = null;
-            fixed (Vector4* native_col = &col)
+            else { native_text = null; }
+            byte hide_text_after_double_hash = 0;
+            float wrap_width = -1.0f;
+            ImGuiNative.igCalcTextSize(&__retval, native_text, native_text+text_byteCount, hide_text_after_double_hash, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, ref_col);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_text);
             }
+            return __retval;
         }
-        public static bool ColorPicker4(string label, ref Vector4 col, ImGuiColorEditFlags flags)
+#endif
+        public static Vector2 CalcTextSize(string text)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            Vector2 __retval;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
             }
-            else { native_label = null; }
-            float* ref_col = null;
-            fixed (Vector4* native_col = &col)
+            else { native_text = null; }
+            byte hide_text_after_double_hash = 0;
+            float wrap_width = -1.0f;
+            ImGuiNative.igCalcTextSize(&__retval, native_text, native_text+text_byteCount, hide_text_after_double_hash, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, ref_col);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_text);
             }
+            return __retval;
         }
-        public static bool ColorPicker4(string label, ref Vector4 col, ImGuiColorEditFlags flags, ref float ref_col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, bool hide_text_after_double_hash)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            Vector2 __retval;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
             }
-            else { native_label = null; }
-            fixed (Vector4* native_col = &col)
+            else { native_text = null; }
+            byte native_hide_text_after_double_hash = hide_text_after_double_hash ? (byte)1 : (byte)0;
+            float wrap_width = -1.0f;
+            ImGuiNative.igCalcTextSize(&__retval, native_text, native_text+text_byteCount, native_hide_text_after_double_hash, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
             {
-                fixed (float* native_ref_col = &ref_col)
-                {
-                    byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, native_ref_col);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    return ret != 0;
-                }
+                Util.Free(native_text);
             }
+            return __retval;
         }
-        public static void Columns()
-        {
-            int count = 1;
-            byte* native_id = null;
-            byte border = 1;
-            ImGuiNative.igColumns(count, native_id, border);
-        }
-        public static void Columns(int count)
+#endif
+        public static Vector2 CalcTextSize(string text, bool hide_text_after_double_hash)
         {
-            byte* native_id = null;
-            byte border = 1;
-            ImGuiNative.igColumns(count, native_id, border);
+            Vector2 __retval;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            byte native_hide_text_after_double_hash = hide_text_after_double_hash ? (byte)1 : (byte)0;
+            float wrap_width = -1.0f;
+            ImGuiNative.igCalcTextSize(&__retval, native_text, native_text+text_byteCount, native_hide_text_after_double_hash, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+            return __retval;
         }
-        public static void Columns(int count, string id)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, bool hide_text_after_double_hash, float wrap_width)
         {
-            byte* native_id;
-            int id_byteCount = 0;
-            if (id != null)
+            Vector2 __retval;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
             {
-                id_byteCount = Encoding.UTF8.GetByteCount(id);
-                if (id_byteCount > Util.StackAllocationSizeLimit)
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_id = Util.Allocate(id_byteCount + 1);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1];
-                    native_id = native_id_stackBytes;
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount);
-                native_id[native_id_offset] = 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
             }
-            else { native_id = null; }
-            byte border = 1;
-            ImGuiNative.igColumns(count, native_id, border);
-            if (id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_text = null; }
+            byte native_hide_text_after_double_hash = hide_text_after_double_hash ? (byte)1 : (byte)0;
+            ImGuiNative.igCalcTextSize(&__retval, native_text, native_text+text_byteCount, native_hide_text_after_double_hash, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_id);
+                Util.Free(native_text);
             }
+            return __retval;
         }
-        public static void Columns(int count, string id, bool border)
+#endif
+        public static Vector2 CalcTextSize(string text, bool hide_text_after_double_hash, float wrap_width)
         {
-            byte* native_id;
-            int id_byteCount = 0;
-            if (id != null)
+            Vector2 __retval;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
             {
-                id_byteCount = Encoding.UTF8.GetByteCount(id);
-                if (id_byteCount > Util.StackAllocationSizeLimit)
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_id = Util.Allocate(id_byteCount + 1);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1];
-                    native_id = native_id_stackBytes;
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount);
-                native_id[native_id_offset] = 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
             }
-            else { native_id = null; }
-            byte native_border = border ? (byte)1 : (byte)0;
-            ImGuiNative.igColumns(count, native_id, native_border);
-            if (id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_text = null; }
+            byte native_hide_text_after_double_hash = hide_text_after_double_hash ? (byte)1 : (byte)0;
+            ImGuiNative.igCalcTextSize(&__retval, native_text, native_text+text_byteCount, native_hide_text_after_double_hash, wrap_width);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_id);
+                Util.Free(native_text);
             }
+            return __retval;
         }
-        public static bool Combo(string label, ref int current_item, string[] items, int items_count)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Checkbox(ReadOnlySpan<char> label, ref bool v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1840,45 +2710,18 @@ public static bool Combo(string label, ref int current_item, string[] items, int
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int* items_byteCounts = stackalloc int[items.Length];
-            int items_byteCount = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                string s = items[i];
-                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
-                items_byteCount += items_byteCounts[i] + 1;
-            }
-            byte* native_items_data = stackalloc byte[items_byteCount];
-            int offset = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                string s = items[i];
-                fixed (char* sPtr = s)
-                {
-                    offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_items_data + offset, items_byteCounts[i]);
-                    native_items_data[offset] = 0;
-                    offset += 1;
-                }
-            }
-            byte** native_items = stackalloc byte*[items.Length];
-            offset = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                native_items[i] = &native_items_data[offset];
-                offset += items_byteCounts[i] + 1;
-            }
-            int popup_max_height_in_items = -1;
-            fixed (int* native_current_item = &current_item)
+            byte native_v_val = v ? (byte)1 : (byte)0;
+            byte* native_v = &native_v_val;
+            byte ret = ImGuiNative.igCheckbox(native_label, native_v);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igCombo(native_label, native_current_item, native_items, items_count, popup_max_height_in_items);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            v = native_v_val != 0;
+            return ret != 0;
         }
-        public static bool Combo(string label, ref int current_item, string[] items, int items_count, int popup_max_height_in_items)
+#endif
+        public static bool Checkbox(string label, ref bool v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1898,44 +2741,18 @@ public static bool Combo(string label, ref int current_item, string[] items, int
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int* items_byteCounts = stackalloc int[items.Length];
-            int items_byteCount = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                string s = items[i];
-                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
-                items_byteCount += items_byteCounts[i] + 1;
-            }
-            byte* native_items_data = stackalloc byte[items_byteCount];
-            int offset = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                string s = items[i];
-                fixed (char* sPtr = s)
-                {
-                    offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_items_data + offset, items_byteCounts[i]);
-                    native_items_data[offset] = 0;
-                    offset += 1;
-                }
-            }
-            byte** native_items = stackalloc byte*[items.Length];
-            offset = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                native_items[i] = &native_items_data[offset];
-                offset += items_byteCounts[i] + 1;
-            }
-            fixed (int* native_current_item = &current_item)
+            byte native_v_val = v ? (byte)1 : (byte)0;
+            byte* native_v = &native_v_val;
+            byte ret = ImGuiNative.igCheckbox(native_label, native_v);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igCombo(native_label, native_current_item, native_items, items_count, popup_max_height_in_items);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            v = native_v_val != 0;
+            return ret != 0;
         }
-        public static bool Combo(string label, ref int current_item, string items_separated_by_zeros)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool CheckboxFlags(ReadOnlySpan<char> label, ref int flags, int flags_value)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -1955,40 +2772,18 @@ public static bool Combo(string label, ref int current_item, string items_separa
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_items_separated_by_zeros;
-            int items_separated_by_zeros_byteCount = 0;
-            if (items_separated_by_zeros != null)
-            {
-                items_separated_by_zeros_byteCount = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
-                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_items_separated_by_zeros = Util.Allocate(items_separated_by_zeros_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_items_separated_by_zeros_stackBytes = stackalloc byte[items_separated_by_zeros_byteCount + 1];
-                    native_items_separated_by_zeros = native_items_separated_by_zeros_stackBytes;
-                }
-                int native_items_separated_by_zeros_offset = Util.GetUtf8(items_separated_by_zeros, native_items_separated_by_zeros, items_separated_by_zeros_byteCount);
-                native_items_separated_by_zeros[native_items_separated_by_zeros_offset] = 0;
-            }
-            else { native_items_separated_by_zeros = null; }
-            int popup_max_height_in_items = -1;
-            fixed (int* native_current_item = &current_item)
+            fixed (int* native_flags = &flags)
             {
-                byte ret = ImGuiNative.igComboStr(native_label, native_current_item, native_items_separated_by_zeros, popup_max_height_in_items);
+                byte ret = ImGuiNative.igCheckboxFlags_IntPtr(native_label, native_flags, flags_value);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_items_separated_by_zeros);
-                }
                 return ret != 0;
             }
         }
-        public static bool Combo(string label, ref int current_item, string items_separated_by_zeros, int popup_max_height_in_items)
+#endif
+        public static bool CheckboxFlags(string label, ref int flags, int flags_value)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2008,87 +2803,49 @@ public static bool Combo(string label, ref int current_item, string items_separa
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_items_separated_by_zeros;
-            int items_separated_by_zeros_byteCount = 0;
-            if (items_separated_by_zeros != null)
-            {
-                items_separated_by_zeros_byteCount = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
-                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_items_separated_by_zeros = Util.Allocate(items_separated_by_zeros_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_items_separated_by_zeros_stackBytes = stackalloc byte[items_separated_by_zeros_byteCount + 1];
-                    native_items_separated_by_zeros = native_items_separated_by_zeros_stackBytes;
-                }
-                int native_items_separated_by_zeros_offset = Util.GetUtf8(items_separated_by_zeros, native_items_separated_by_zeros, items_separated_by_zeros_byteCount);
-                native_items_separated_by_zeros[native_items_separated_by_zeros_offset] = 0;
-            }
-            else { native_items_separated_by_zeros = null; }
-            fixed (int* native_current_item = &current_item)
+            fixed (int* native_flags = &flags)
             {
-                byte ret = ImGuiNative.igComboStr(native_label, native_current_item, native_items_separated_by_zeros, popup_max_height_in_items);
+                byte ret = ImGuiNative.igCheckboxFlags_IntPtr(native_label, native_flags, flags_value);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_items_separated_by_zeros);
-                }
                 return ret != 0;
             }
         }
-        public static IntPtr CreateContext()
-        {
-            ImFontAtlas* shared_font_atlas = null;
-            IntPtr ret = ImGuiNative.igCreateContext(shared_font_atlas);
-            return ret;
-        }
-        public static IntPtr CreateContext(ImFontAtlasPtr shared_font_atlas)
-        {
-            ImFontAtlas* native_shared_font_atlas = shared_font_atlas.NativePtr;
-            IntPtr ret = ImGuiNative.igCreateContext(native_shared_font_atlas);
-            return ret;
-        }
-        public static bool DebugCheckVersionAndDataLayout(string version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool CheckboxFlags(ReadOnlySpan<char> label, ref uint flags, uint flags_value)
         {
-            byte* native_version_str;
-            int version_str_byteCount = 0;
-            if (version_str != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                version_str_byteCount = Encoding.UTF8.GetByteCount(version_str);
-                if (version_str_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_version_str = Util.Allocate(version_str_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_version_str_stackBytes = stackalloc byte[version_str_byteCount + 1];
-                    native_version_str = native_version_str_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_version_str_offset = Util.GetUtf8(version_str, native_version_str, version_str_byteCount);
-                native_version_str[native_version_str_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_version_str = null; }
-            byte ret = ImGuiNative.igDebugCheckVersionAndDataLayout(native_version_str, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert);
-            if (version_str_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            fixed (uint* native_flags = &flags)
             {
-                Util.Free(native_version_str);
+                byte ret = ImGuiNative.igCheckboxFlags_UintPtr(native_label, native_flags, flags_value);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static void DestroyContext()
-        {
-            IntPtr ctx = IntPtr.Zero;
-            ImGuiNative.igDestroyContext(ctx);
-        }
-        public static void DestroyContext(IntPtr ctx)
-        {
-            ImGuiNative.igDestroyContext(ctx);
-        }
-        public static bool DragFloat(string label, ref float v)
+#endif
+        public static bool CheckboxFlags(string label, ref uint flags, uint flags_value)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2108,39 +2865,22 @@ public static bool DragFloat(string label, ref float v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            fixed (uint* native_flags = &flags)
             {
-                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igCheckboxFlags_UintPtr(native_label, native_flags, flags_value);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat(string label, ref float v, float v_speed)
+        public static void CloseCurrentPopup()
+        {
+            ImGuiNative.igCloseCurrentPopup();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool CollapsingHeader(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2160,38 +2900,16 @@ public static bool DragFloat(string label, ref float v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            ImGuiTreeNodeFlags flags = (ImGuiTreeNodeFlags)0;
+            byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool DragFloat(string label, ref float v, float v_speed, float v_min)
+#endif
+        public static bool CollapsingHeader(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2211,37 +2929,16 @@ public static bool DragFloat(string label, ref float v, float v_speed, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            ImGuiTreeNodeFlags flags = (ImGuiTreeNodeFlags)0;
+            byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool CollapsingHeader(ReadOnlySpan<char> label, ImGuiTreeNodeFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2261,36 +2958,15 @@ public static bool DragFloat(string label, ref float v, float v_speed, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max, string format)
+#endif
+        public static bool CollapsingHeader(string label, ImGuiTreeNodeFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2310,40 +2986,15 @@ public static bool DragFloat(string label, ref float v, float v_speed, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max, string format, float power)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool CollapsingHeader(ReadOnlySpan<char> label, ref bool p_visible)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2363,39 +3014,19 @@ public static bool DragFloat(string label, ref float v, float v_speed, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (float* native_v = &v)
+            byte native_p_visible_val = p_visible ? (byte)1 : (byte)0;
+            byte* native_p_visible = &native_p_visible_val;
+            ImGuiTreeNodeFlags flags = (ImGuiTreeNodeFlags)0;
+            byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(native_label, native_p_visible, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            p_visible = native_p_visible_val != 0;
+            return ret != 0;
         }
-        public static bool DragFloat2(string label, ref Vector2 v)
+#endif
+        public static bool CollapsingHeader(string label, ref bool p_visible)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2415,39 +3046,19 @@ public static bool DragFloat2(string label, ref Vector2 v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+            byte native_p_visible_val = p_visible ? (byte)1 : (byte)0;
+            byte* native_p_visible = &native_p_visible_val;
+            ImGuiTreeNodeFlags flags = (ImGuiTreeNodeFlags)0;
+            byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(native_label, native_p_visible, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            p_visible = native_p_visible_val != 0;
+            return ret != 0;
         }
-        public static bool DragFloat2(string label, ref Vector2 v, float v_speed)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool CollapsingHeader(ReadOnlySpan<char> label, ref bool p_visible, ImGuiTreeNodeFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2467,38 +3078,18 @@ public static bool DragFloat2(string label, ref Vector2 v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+            byte native_p_visible_val = p_visible ? (byte)1 : (byte)0;
+            byte* native_p_visible = &native_p_visible_val;
+            byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(native_label, native_p_visible, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            p_visible = native_p_visible_val != 0;
+            return ret != 0;
         }
-        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min)
+#endif
+        public static bool CollapsingHeader(string label, ref bool p_visible, ImGuiTreeNodeFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2518,139 +3109,229 @@ public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            byte native_p_visible_val = p_visible ? (byte)1 : (byte)0;
+            byte* native_p_visible = &native_p_visible_val;
+            byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(native_label, native_p_visible, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_visible = native_p_visible_val != 0;
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorButton(ReadOnlySpan<char> desc_id, Vector4 col)
+        {
+            byte* native_desc_id;
+            int desc_id_byteCount = 0;
+            if (desc_id != null)
+            {
+                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
+                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
+                    native_desc_id = native_desc_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
+                native_desc_id[native_desc_id_offset] = 0;
+            }
+            else { native_desc_id = null; }
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
+            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_desc_id);
             }
+            return ret != 0;
         }
-        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max)
+#endif
+        public static bool ColorButton(string desc_id, Vector4 col)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_desc_id;
+            int desc_id_byteCount = 0;
+            if (desc_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
+                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
+                    native_desc_id = native_desc_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
+                native_desc_id[native_desc_id_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_desc_id = null; }
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
+            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_desc_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorButton(ReadOnlySpan<char> desc_id, Vector4 col, ImGuiColorEditFlags flags)
+        {
+            byte* native_desc_id;
+            int desc_id_byteCount = 0;
+            if (desc_id != null)
+            {
+                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
+                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
+                    native_desc_id = native_desc_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
+                native_desc_id[native_desc_id_offset] = 0;
+            }
+            else { native_desc_id = null; }
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
+            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_desc_id);
             }
+            return ret != 0;
         }
-        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max, string format)
+#endif
+        public static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_desc_id;
+            int desc_id_byteCount = 0;
+            if (desc_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
+                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
-                }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
+                    native_desc_id = native_desc_id_stackBytes;
+                }
+                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
+                native_desc_id[native_desc_id_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_desc_id = null; }
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
+            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_desc_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorButton(ReadOnlySpan<char> desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size)
+        {
+            byte* native_desc_id;
+            int desc_id_byteCount = 0;
+            if (desc_id != null)
+            {
+                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
+                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
+                    native_desc_id = native_desc_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
+                native_desc_id[native_desc_id_offset] = 0;
             }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+            else { native_desc_id = null; }
+            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
+            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_desc_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size)
+        {
+            byte* native_desc_id;
+            int desc_id_byteCount = 0;
+            if (desc_id != null)
+            {
+                desc_id_byteCount = Encoding.UTF8.GetByteCount(desc_id);
+                if (desc_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_desc_id = Util.Allocate(desc_id_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_desc_id_stackBytes = stackalloc byte[desc_id_byteCount + 1];
+                    native_desc_id = native_desc_id_stackBytes;
+                }
+                int native_desc_id_offset = Util.GetUtf8(desc_id, native_desc_id, desc_id_byteCount);
+                native_desc_id[native_desc_id_offset] = 0;
+            }
+            else { native_desc_id = null; }
+            byte ret = ImGuiNative.igColorButton(native_desc_id, col, flags, size);
+            if (desc_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_desc_id);
+            }
+            return ret != 0;
+        }
+        public static uint ColorConvertFloat4ToU32(Vector4 @in)
+        {
+            uint ret = ImGuiNative.igColorConvertFloat4ToU32(@in);
+            return ret;
+        }
+        public static void ColorConvertHSVtoRGB(float h, float s, float v, out float out_r, out float out_g, out float out_b)
+        {
+            fixed (float* native_out_r = &out_r)
+            {
+                fixed (float* native_out_g = &out_g)
+                {
+                    fixed (float* native_out_b = &out_b)
+                    {
+                        ImGuiNative.igColorConvertHSVtoRGB(h, s, v, native_out_r, native_out_g, native_out_b);
+                    }
+                }
+            }
+        }
+        public static void ColorConvertRGBtoHSV(float r, float g, float b, out float out_h, out float out_s, out float out_v)
+        {
+            fixed (float* native_out_h = &out_h)
+            {
+                fixed (float* native_out_s = &out_s)
+                {
+                    fixed (float* native_out_v = &out_v)
+                    {
+                        ImGuiNative.igColorConvertRGBtoHSV(r, g, b, native_out_h, native_out_s, native_out_v);
+                    }
                 }
-                return ret != 0;
             }
         }
-        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max, string format, float power)
+        public static Vector4 ColorConvertU32ToFloat4(uint @in)
+        {
+            Vector4 __retval;
+            ImGuiNative.igColorConvertU32ToFloat4(&__retval, @in);
+            return __retval;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorEdit3(ReadOnlySpan<char> label, ref Vector3 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2670,39 +3351,19 @@ public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (Vector2* native_v = &v)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat3(string label, ref Vector3 v)
+#endif
+        public static bool ColorEdit3(string label, ref Vector3 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2722,39 +3383,19 @@ public static bool DragFloat3(string label, ref Vector3 v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat3(string label, ref Vector3 v, float v_speed)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorEdit3(ReadOnlySpan<char> label, ref Vector3 col, ImGuiColorEditFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2774,38 +3415,18 @@ public static bool DragFloat3(string label, ref Vector3 v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min)
+#endif
+        public static bool ColorEdit3(string label, ref Vector3 col, ImGuiColorEditFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2825,37 +3446,18 @@ public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorEdit4(ReadOnlySpan<char> label, ref Vector4 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2875,36 +3477,19 @@ public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            fixed (Vector4* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit4(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max, string format)
+#endif
+        public static bool ColorEdit4(string label, ref Vector4 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2924,40 +3509,19 @@ public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            fixed (Vector4* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit4(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max, string format, float power)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorEdit4(ReadOnlySpan<char> label, ref Vector4 col, ImGuiColorEditFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -2977,39 +3541,49 @@ public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            fixed (Vector4* native_col = &col)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igColorEdit4(native_label, native_col, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool ColorEdit4(string label, ref Vector4 col, ImGuiColorEditFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (Vector3* native_v = &v)
+            else { native_label = null; }
+            fixed (Vector4* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorEdit4(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat4(string label, ref Vector4 v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorPicker3(ReadOnlySpan<char> label, ref Vector3 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3029,39 +3603,19 @@ public static bool DragFloat4(string label, ref Vector4 v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorPicker3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat4(string label, ref Vector4 v, float v_speed)
+#endif
+        public static bool ColorPicker3(string label, ref Vector3 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3081,38 +3635,19 @@ public static bool DragFloat4(string label, ref Vector4 v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorPicker3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorPicker3(ReadOnlySpan<char> label, ref Vector3 col, ImGuiColorEditFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3132,37 +3667,18 @@ public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorPicker3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max)
+#endif
+        public static bool ColorPicker3(string label, ref Vector3 col, ImGuiColorEditFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3182,36 +3698,18 @@ public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            fixed (Vector3* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorPicker3(native_label, native_col, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorPicker4(ReadOnlySpan<char> label, ref Vector4 col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3231,40 +3729,53 @@ public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            float* ref_col = null;
+            fixed (Vector4* native_col = &col)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, ref_col);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool ColorPicker4(string label, ref Vector4 col)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            else { native_label = null; }
+            ImGuiColorEditFlags flags = (ImGuiColorEditFlags)0;
+            float* ref_col = null;
+            fixed (Vector4* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, ref_col);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max, string format, float power)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorPicker4(ReadOnlySpan<char> label, ref Vector4 col, ImGuiColorEditFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3284,39 +3795,51 @@ public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            float* ref_col = null;
+            fixed (Vector4* native_col = &col)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, ref_col);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool ColorPicker4(string label, ref Vector4 col, ImGuiColorEditFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (Vector4* native_v = &v)
+            else { native_label = null; }
+            float* ref_col = null;
+            fixed (Vector4* native_col = &col)
             {
-                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, ref_col);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
                 return ret != 0;
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColorPicker4(ReadOnlySpan<char> label, ref Vector4 col, ImGuiColorEditFlags flags, ref float ref_col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3336,43 +3859,21 @@ public static bool DragFloatRange2(string label, ref float v_current_min, ref fl
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            float power = 1.0f;
-            fixed (float* native_v_current_min = &v_current_min)
+            fixed (Vector4* native_col = &col)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                fixed (float* native_ref_col = &ref_col)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
+                    byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, native_ref_col);
                     if (label_byteCount > Util.StackAllocationSizeLimit)
                     {
                         Util.Free(native_label);
                     }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
                     return ret != 0;
                 }
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed)
+#endif
+        public static bool ColorPicker4(string label, ref Vector4 col, ImGuiColorEditFlags flags, ref float ref_col)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3392,96 +3893,146 @@ public static bool DragFloatRange2(string label, ref float v_current_min, ref fl
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_min = 0.0f;
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            float power = 1.0f;
-            fixed (float* native_v_current_min = &v_current_min)
+            fixed (Vector4* native_col = &col)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                fixed (float* native_ref_col = &ref_col)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
+                    byte ret = ImGuiNative.igColorPicker4(native_label, native_col, flags, native_ref_col);
                     if (label_byteCount > Util.StackAllocationSizeLimit)
                     {
                         Util.Free(native_label);
                     }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
                     return ret != 0;
                 }
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min)
+        public static void Columns()
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            int count = 1;
+            byte* native_id = null;
+            byte borders = 1;
+            ImGuiNative.igColumns(count, native_id, borders);
+        }
+        public static void Columns(int count)
+        {
+            byte* native_id = null;
+            byte borders = 1;
+            ImGuiNative.igColumns(count, native_id, borders);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Columns(int count, ReadOnlySpan<char> id)
+        {
+            byte* native_id;
+            int id_byteCount = 0;
+            if (id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                id_byteCount = Encoding.UTF8.GetByteCount(id);
+                if (id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_id = Util.Allocate(id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1];
+                    native_id = native_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount);
+                native_id[native_id_offset] = 0;
             }
-            else { native_label = null; }
-            float v_max = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_id = null; }
+            byte borders = 1;
+            ImGuiNative.igColumns(count, native_id, borders);
+            if (id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_id);
+            }
+        }
+#endif
+        public static void Columns(int count, string id)
+        {
+            byte* native_id;
+            int id_byteCount = 0;
+            if (id != null)
+            {
+                id_byteCount = Encoding.UTF8.GetByteCount(id);
+                if (id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_id = Util.Allocate(id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1];
+                    native_id = native_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            float power = 1.0f;
-            fixed (float* native_v_current_min = &v_current_min)
+                int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount);
+                native_id[native_id_offset] = 0;
+            }
+            else { native_id = null; }
+            byte borders = 1;
+            ImGuiNative.igColumns(count, native_id, borders);
+            if (id_byteCount > Util.StackAllocationSizeLimit)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                Util.Free(native_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Columns(int count, ReadOnlySpan<char> id, bool borders)
+        {
+            byte* native_id;
+            int id_byteCount = 0;
+            if (id != null)
+            {
+                id_byteCount = Encoding.UTF8.GetByteCount(id);
+                if (id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    native_id = Util.Allocate(id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1];
+                    native_id = native_id_stackBytes;
                 }
+                int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount);
+                native_id[native_id_offset] = 0;
+            }
+            else { native_id = null; }
+            byte native_borders = borders ? (byte)1 : (byte)0;
+            ImGuiNative.igColumns(count, native_id, native_borders);
+            if (id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_id);
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max)
+#endif
+        public static void Columns(int count, string id, bool borders)
+        {
+            byte* native_id;
+            int id_byteCount = 0;
+            if (id != null)
+            {
+                id_byteCount = Encoding.UTF8.GetByteCount(id);
+                if (id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_id = Util.Allocate(id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_id_stackBytes = stackalloc byte[id_byteCount + 1];
+                    native_id = native_id_stackBytes;
+                }
+                int native_id_offset = Util.GetUtf8(id, native_id, id_byteCount);
+                native_id[native_id_offset] = 0;
+            }
+            else { native_id = null; }
+            byte native_borders = borders ? (byte)1 : (byte)0;
+            ImGuiNative.igColumns(count, native_id, native_borders);
+            if (id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Combo(ReadOnlySpan<char> label, ref int current_item, string[] items, int items_count)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3501,40 +4052,42 @@ public static bool DragFloatRange2(string label, ref float v_current_min, ref fl
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            float power = 1.0f;
-            fixed (float* native_v_current_min = &v_current_min)
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
+            }
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
+            }
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            int popup_max_height_in_items = -1;
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igCombo_Str_arr(native_label, native_current_item, native_items, items_count, popup_max_height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format)
+#endif
+        public static bool Combo(string label, ref int current_item, string[] items, int items_count)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3554,44 +4107,42 @@ public static bool DragFloatRange2(string label, ref float v_current_min, ref fl
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
             }
-            else { native_format = null; }
-            byte* native_format_max = null;
-            float power = 1.0f;
-            fixed (float* native_v_current_min = &v_current_min)
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
+            }
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            int popup_max_height_in_items = -1;
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igCombo_Str_arr(native_label, native_current_item, native_items, items_count, popup_max_height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format, string format_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Combo(ReadOnlySpan<char> label, ref int current_item, string[] items, int items_count, int popup_max_height_in_items)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3611,65 +4162,41 @@ public static bool DragFloatRange2(string label, ref float v_current_min, ref fl
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
             }
-            else { native_format = null; }
-            byte* native_format_max;
-            int format_max_byteCount = 0;
-            if (format_max != null)
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
-                if (format_max_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format_max = Util.Allocate(format_max_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
-                    native_format_max = native_format_max_stackBytes;
-                }
-                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
-                native_format_max[native_format_max_offset] = 0;
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
             }
-            else { native_format_max = null; }
-            float power = 1.0f;
-            fixed (float* native_v_current_min = &v_current_min)
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igCombo_Str_arr(native_label, native_current_item, native_items, items_count, popup_max_height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format_max);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format, string format_max, float power)
+#endif
+        public static bool Combo(string label, ref int current_item, string[] items, int items_count, int popup_max_height_in_items)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3689,64 +4216,41 @@ public static bool DragFloatRange2(string label, ref float v_current_min, ref fl
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
             }
-            else { native_format = null; }
-            byte* native_format_max;
-            int format_max_byteCount = 0;
-            if (format_max != null)
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
-                if (format_max_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format_max = Util.Allocate(format_max_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
-                    native_format_max = native_format_max_stackBytes;
-                }
-                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
-                native_format_max[native_format_max_offset] = 0;
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
             }
-            else { native_format_max = null; }
-            fixed (float* native_v_current_min = &v_current_min)
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
             {
-                fixed (float* native_v_current_max = &v_current_max)
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igCombo_Str_arr(native_label, native_current_item, native_items, items_count, popup_max_height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, power);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format_max);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragInt(string label, ref int v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Combo(ReadOnlySpan<char> label, ref int current_item, ReadOnlySpan<char> items_separated_by_zeros)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3766,38 +4270,41 @@ public static bool DragInt(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            int v_min = 0;
-            int v_max = 0;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_items_separated_by_zeros;
+            int items_separated_by_zeros_byteCount = 0;
+            if (items_separated_by_zeros != null)
+            {
+                items_separated_by_zeros_byteCount = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_items_separated_by_zeros = Util.Allocate(items_separated_by_zeros_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_items_separated_by_zeros_stackBytes = stackalloc byte[items_separated_by_zeros_byteCount + 1];
+                    native_items_separated_by_zeros = native_items_separated_by_zeros_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+                int native_items_separated_by_zeros_offset = Util.GetUtf8(items_separated_by_zeros, native_items_separated_by_zeros, items_separated_by_zeros_byteCount);
+                native_items_separated_by_zeros[native_items_separated_by_zeros_offset] = 0;
+            }
+            else { native_items_separated_by_zeros = null; }
+            int popup_max_height_in_items = -1;
+            fixed (int* native_current_item = &current_item)
             {
-                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igCombo_Str(native_label, native_current_item, native_items_separated_by_zeros, popup_max_height_in_items);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_format);
+                    Util.Free(native_items_separated_by_zeros);
                 }
                 return ret != 0;
             }
         }
-        public static bool DragInt(string label, ref int v, float v_speed)
+#endif
+        public static bool Combo(string label, ref int current_item, string items_separated_by_zeros)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3817,37 +4324,41 @@ public static bool DragInt(string label, ref int v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_min = 0;
-            int v_max = 0;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_items_separated_by_zeros;
+            int items_separated_by_zeros_byteCount = 0;
+            if (items_separated_by_zeros != null)
+            {
+                items_separated_by_zeros_byteCount = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_items_separated_by_zeros = Util.Allocate(items_separated_by_zeros_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_items_separated_by_zeros_stackBytes = stackalloc byte[items_separated_by_zeros_byteCount + 1];
+                    native_items_separated_by_zeros = native_items_separated_by_zeros_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+                int native_items_separated_by_zeros_offset = Util.GetUtf8(items_separated_by_zeros, native_items_separated_by_zeros, items_separated_by_zeros_byteCount);
+                native_items_separated_by_zeros[native_items_separated_by_zeros_offset] = 0;
+            }
+            else { native_items_separated_by_zeros = null; }
+            int popup_max_height_in_items = -1;
+            fixed (int* native_current_item = &current_item)
             {
-                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igCombo_Str(native_label, native_current_item, native_items_separated_by_zeros, popup_max_height_in_items);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_format);
+                    Util.Free(native_items_separated_by_zeros);
                 }
                 return ret != 0;
             }
         }
-        public static bool DragInt(string label, ref int v, float v_speed, int v_min)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Combo(ReadOnlySpan<char> label, ref int current_item, ReadOnlySpan<char> items_separated_by_zeros, int popup_max_height_in_items)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3867,36 +4378,40 @@ public static bool DragInt(string label, ref int v, float v_speed, int v_min)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_max = 0;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_items_separated_by_zeros;
+            int items_separated_by_zeros_byteCount = 0;
+            if (items_separated_by_zeros != null)
+            {
+                items_separated_by_zeros_byteCount = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_items_separated_by_zeros = Util.Allocate(items_separated_by_zeros_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_items_separated_by_zeros_stackBytes = stackalloc byte[items_separated_by_zeros_byteCount + 1];
+                    native_items_separated_by_zeros = native_items_separated_by_zeros_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+                int native_items_separated_by_zeros_offset = Util.GetUtf8(items_separated_by_zeros, native_items_separated_by_zeros, items_separated_by_zeros_byteCount);
+                native_items_separated_by_zeros[native_items_separated_by_zeros_offset] = 0;
+            }
+            else { native_items_separated_by_zeros = null; }
+            fixed (int* native_current_item = &current_item)
             {
-                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igCombo_Str(native_label, native_current_item, native_items_separated_by_zeros, popup_max_height_in_items);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_format);
+                    Util.Free(native_items_separated_by_zeros);
                 }
                 return ret != 0;
             }
         }
-        public static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max)
+#endif
+        public static bool Combo(string label, ref int current_item, string items_separated_by_zeros, int popup_max_height_in_items)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -3916,87 +4431,303 @@ public static bool DragInt(string label, ref int v, float v_speed, int v_min, in
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_items_separated_by_zeros;
+            int items_separated_by_zeros_byteCount = 0;
+            if (items_separated_by_zeros != null)
+            {
+                items_separated_by_zeros_byteCount = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_items_separated_by_zeros = Util.Allocate(items_separated_by_zeros_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_items_separated_by_zeros_stackBytes = stackalloc byte[items_separated_by_zeros_byteCount + 1];
+                    native_items_separated_by_zeros = native_items_separated_by_zeros_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+                int native_items_separated_by_zeros_offset = Util.GetUtf8(items_separated_by_zeros, native_items_separated_by_zeros, items_separated_by_zeros_byteCount);
+                native_items_separated_by_zeros[native_items_separated_by_zeros_offset] = 0;
+            }
+            else { native_items_separated_by_zeros = null; }
+            fixed (int* native_current_item = &current_item)
             {
-                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igCombo_Str(native_label, native_current_item, native_items_separated_by_zeros, popup_max_height_in_items);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                if (items_separated_by_zeros_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_format);
+                    Util.Free(native_items_separated_by_zeros);
                 }
                 return ret != 0;
             }
         }
-        public static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+        public static IntPtr CreateContext()
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            ImFontAtlas* shared_font_atlas = null;
+            IntPtr ret = ImGuiNative.igCreateContext(shared_font_atlas);
+            return ret;
+        }
+        public static IntPtr CreateContext(ImFontAtlasPtr shared_font_atlas)
+        {
+            ImFontAtlas* native_shared_font_atlas = shared_font_atlas.NativePtr;
+            IntPtr ret = ImGuiNative.igCreateContext(native_shared_font_atlas);
+            return ret;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DebugCheckVersionAndDataLayout(ReadOnlySpan<char> version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert, uint sz_drawidx)
+        {
+            byte* native_version_str;
+            int version_str_byteCount = 0;
+            if (version_str != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                version_str_byteCount = Encoding.UTF8.GetByteCount(version_str);
+                if (version_str_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_version_str = Util.Allocate(version_str_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_version_str_stackBytes = stackalloc byte[version_str_byteCount + 1];
+                    native_version_str = native_version_str_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_version_str_offset = Util.GetUtf8(version_str, native_version_str, version_str_byteCount);
+                native_version_str[native_version_str_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_version_str = null; }
+            byte ret = ImGuiNative.igDebugCheckVersionAndDataLayout(native_version_str, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
+            if (version_str_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_version_str);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DebugCheckVersionAndDataLayout(string version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert, uint sz_drawidx)
+        {
+            byte* native_version_str;
+            int version_str_byteCount = 0;
+            if (version_str != null)
+            {
+                version_str_byteCount = Encoding.UTF8.GetByteCount(version_str);
+                if (version_str_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_version_str = Util.Allocate(version_str_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_version_str_stackBytes = stackalloc byte[version_str_byteCount + 1];
+                    native_version_str = native_version_str_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_version_str_offset = Util.GetUtf8(version_str, native_version_str, version_str_byteCount);
+                native_version_str[native_version_str_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            else { native_version_str = null; }
+            byte ret = ImGuiNative.igDebugCheckVersionAndDataLayout(native_version_str, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
+            if (version_str_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_version_str);
+            }
+            return ret != 0;
+        }
+        public static void DebugFlashStyleColor(ImGuiCol idx)
+        {
+            ImGuiNative.igDebugFlashStyleColor(idx);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void DebugLog(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                return ret != 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igDebugLog(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
         }
-        public static bool DragInt2(string label, ref int v)
+#endif
+        public static void DebugLog(string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igDebugLog(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+        public static void DebugStartItemPicker()
+        {
+            ImGuiNative.igDebugStartItemPicker();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void DebugTextEncoding(ReadOnlySpan<char> text)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.igDebugTextEncoding(native_text);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#endif
+        public static void DebugTextEncoding(string text)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.igDebugTextEncoding(native_text);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+        public static void DestroyContext()
+        {
+            IntPtr ctx = IntPtr.Zero;
+            ImGuiNative.igDestroyContext(ctx);
+        }
+        public static void DestroyContext(IntPtr ctx)
+        {
+            ImGuiNative.igDestroyContext(ctx);
+        }
+        public static void DestroyPlatformWindows()
+        {
+            ImGuiNative.igDestroyPlatformWindows();
+        }
+        public static uint DockSpace(uint dockspace_id)
+        {
+            Vector2 size = new Vector2();
+            ImGuiDockNodeFlags flags = (ImGuiDockNodeFlags)0;
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpace(dockspace_id, size, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpace(uint dockspace_id, Vector2 size)
+        {
+            ImGuiDockNodeFlags flags = (ImGuiDockNodeFlags)0;
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpace(dockspace_id, size, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpace(uint dockspace_id, Vector2 size, ImGuiDockNodeFlags flags)
+        {
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpace(dockspace_id, size, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpace(uint dockspace_id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr window_class)
+        {
+            ImGuiWindowClass* native_window_class = window_class.NativePtr;
+            uint ret = ImGuiNative.igDockSpace(dockspace_id, size, flags, native_window_class);
+            return ret;
+        }
+        public static uint DockSpaceOverViewport()
+        {
+            uint dockspace_id = 0;
+            ImGuiViewport* viewport = null;
+            ImGuiDockNodeFlags flags = (ImGuiDockNodeFlags)0;
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpaceOverViewport(dockspace_id, viewport, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpaceOverViewport(uint dockspace_id)
+        {
+            ImGuiViewport* viewport = null;
+            ImGuiDockNodeFlags flags = (ImGuiDockNodeFlags)0;
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpaceOverViewport(dockspace_id, viewport, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpaceOverViewport(uint dockspace_id, ImGuiViewportPtr viewport)
+        {
+            ImGuiViewport* native_viewport = viewport.NativePtr;
+            ImGuiDockNodeFlags flags = (ImGuiDockNodeFlags)0;
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpaceOverViewport(dockspace_id, native_viewport, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpaceOverViewport(uint dockspace_id, ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags)
+        {
+            ImGuiViewport* native_viewport = viewport.NativePtr;
+            ImGuiWindowClass* window_class = null;
+            uint ret = ImGuiNative.igDockSpaceOverViewport(dockspace_id, native_viewport, flags, window_class);
+            return ret;
+        }
+        public static uint DockSpaceOverViewport(uint dockspace_id, ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr window_class)
+        {
+            ImGuiViewport* native_viewport = viewport.NativePtr;
+            ImGuiWindowClass* native_window_class = window_class.NativePtr;
+            uint ret = ImGuiNative.igDockSpaceOverViewport(dockspace_id, native_viewport, flags, native_window_class);
+            return ret;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat(ReadOnlySpan<char> label, ref float v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4017,11 +4748,11 @@ public static bool DragInt2(string label, ref int v)
             }
             else { native_label = null; }
             float v_speed = 1.0f;
-            int v_min = 0;
-            int v_max = 0;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4031,11 +4762,12 @@ public static bool DragInt2(string label, ref int v)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4047,7 +4779,8 @@ public static bool DragInt2(string label, ref int v)
                 return ret != 0;
             }
         }
-        public static bool DragInt2(string label, ref int v, float v_speed)
+#endif
+        public static bool DragFloat(string label, ref float v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4067,11 +4800,12 @@ public static bool DragInt2(string label, ref int v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_min = 0;
-            int v_max = 0;
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4081,11 +4815,12 @@ public static bool DragInt2(string label, ref int v, float v_speed)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4097,7 +4832,8 @@ public static bool DragInt2(string label, ref int v, float v_speed)
                 return ret != 0;
             }
         }
-        public static bool DragInt2(string label, ref int v, float v_speed, int v_min)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4117,10 +4853,11 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_max = 0;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4130,11 +4867,12 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4146,7 +4884,8 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min)
                 return ret != 0;
             }
         }
-        public static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max)
+#endif
+        public static bool DragFloat(string label, ref float v, float v_speed)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4166,9 +4905,11 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4178,11 +4919,12 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min, i
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4194,7 +4936,8 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min, i
                 return ret != 0;
             }
         }
-        public static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed, float v_min)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4214,11 +4957,10 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4228,13 +4970,12 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min, i
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4246,7 +4987,8 @@ public static bool DragInt2(string label, ref int v, float v_speed, int v_min, i
                 return ret != 0;
             }
         }
-        public static bool DragInt3(string label, ref int v)
+#endif
+        public static bool DragFloat(string label, ref float v, float v_speed, float v_min)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4266,12 +5008,10 @@ public static bool DragInt3(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            int v_min = 0;
-            int v_max = 0;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4281,11 +5021,12 @@ public static bool DragInt3(string label, ref int v)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4297,7 +5038,8 @@ public static bool DragInt3(string label, ref int v)
                 return ret != 0;
             }
         }
-        public static bool DragInt3(string label, ref int v, float v_speed)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4317,11 +5059,9 @@ public static bool DragInt3(string label, ref int v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_min = 0;
-            int v_max = 0;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4331,11 +5071,12 @@ public static bool DragInt3(string label, ref int v, float v_speed)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4347,7 +5088,8 @@ public static bool DragInt3(string label, ref int v, float v_speed)
                 return ret != 0;
             }
         }
-        public static bool DragInt3(string label, ref int v, float v_speed, int v_min)
+#endif
+        public static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4367,10 +5109,9 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_max = 0;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4380,11 +5121,12 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4396,7 +5138,8 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min)
                 return ret != 0;
             }
         }
-        public static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4418,7 +5161,9 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min, i
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4428,11 +5173,14 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min, i
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4444,7 +5192,8 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min, i
                 return ret != 0;
             }
         }
-        public static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+#endif
+        public static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4482,9 +5231,10 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min, i
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4496,7 +5246,8 @@ public static bool DragInt3(string label, ref int v, float v_speed, int v_min, i
                 return ret != 0;
             }
         }
-        public static bool DragInt4(string label, ref int v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4516,12 +5267,11 @@ public static bool DragInt4(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            int v_min = 0;
-            int v_max = 0;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4531,11 +5281,13 @@ public static bool DragInt4(string label, ref int v)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            }
+            else { native_format = null; }
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4547,7 +5299,8 @@ public static bool DragInt4(string label, ref int v)
                 return ret != 0;
             }
         }
-        public static bool DragInt4(string label, ref int v, float v_speed)
+#endif
+        public static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4567,11 +5320,11 @@ public static bool DragInt4(string label, ref int v, float v_speed)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_min = 0;
-            int v_max = 0;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4581,11 +5334,13 @@ public static bool DragInt4(string label, ref int v, float v_speed)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            }
+            else { native_format = null; }
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4597,7 +5352,8 @@ public static bool DragInt4(string label, ref int v, float v_speed)
                 return ret != 0;
             }
         }
-        public static bool DragInt4(string label, ref int v, float v_speed, int v_min)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4617,10 +5373,12 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_max = 0;
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4630,11 +5388,12 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4646,7 +5405,8 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min)
                 return ret != 0;
             }
         }
-        public static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max)
+#endif
+        public static bool DragFloat2(string label, ref Vector2 v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4666,9 +5426,12 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4678,11 +5441,12 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min, i
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4694,7 +5458,8 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min, i
                 return ret != 0;
             }
         }
-        public static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4714,11 +5479,11 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4728,13 +5493,12 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min, i
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -4746,7 +5510,8 @@ public static bool DragInt4(string label, ref int v, float v_speed, int v_min, i
                 return ret != 0;
             }
         }
-        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max)
+#endif
+        public static bool DragFloat2(string label, ref Vector2 v, float v_speed)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4766,12 +5531,11 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_speed = 1.0f;
-            int v_min = 0;
-            int v_max = 0;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4781,27 +5545,25 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            fixed (int* native_v_current_min = &v_current_min)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                fixed (int* native_v_current_max = &v_current_max)
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed, float v_min)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4821,11 +5583,10 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_min = 0;
-            int v_max = 0;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4835,27 +5596,25 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            fixed (int* native_v_current_min = &v_current_min)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                fixed (int* native_v_current_max = &v_current_max)
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min)
+#endif
+        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4875,10 +5634,10 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int v_max = 0;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4888,27 +5647,25 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            fixed (int* native_v_current_min = &v_current_min)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                fixed (int* native_v_current_max = &v_current_max)
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4930,7 +5687,7 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4940,27 +5697,25 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            byte* native_format_max = null;
-            fixed (int* native_v_current_min = &v_current_min)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                fixed (int* native_v_current_max = &v_current_max)
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format)
+#endif
+        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -4982,9 +5737,7 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -4994,29 +5747,25 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            byte* native_format_max = null;
-            fixed (int* native_v_current_min = &v_current_min)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                fixed (int* native_v_current_max = &v_current_max)
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    return ret != 0;
+                    Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format, string format_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5054,46 +5803,23 @@ public static bool DragIntRange2(string label, ref int v_current_min, ref int v_
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            byte* native_format_max;
-            int format_max_byteCount = 0;
-            if (format_max != null)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
-                if (format_max_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format_max = Util.Allocate(format_max_byteCount + 1);
-                }
-                else
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
-                    native_format_max = native_format_max_stackBytes;
+                    Util.Free(native_label);
                 }
-                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
-                native_format_max[native_format_max_offset] = 0;
-            }
-            else { native_format_max = null; }
-            fixed (int* native_v_current_min = &v_current_min)
-            {
-                fixed (int* native_v_current_max = &v_current_max)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max);
-                    if (label_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_label);
-                    }
-                    if (format_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format);
-                    }
-                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
-                    {
-                        Util.Free(native_format_max);
-                    }
-                    return ret != 0;
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, float v_speed)
+#endif
+        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5113,83 +5839,41 @@ public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, f
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* v_min = null;
-            void* v_max = null;
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_v, v_speed, v_min, v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            return ret != 0;
-        }
-        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, float v_speed, IntPtr v_min)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
-            }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* v_max = null;
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_v, v_speed, native_v_min, v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            return ret != 0;
-        }
-        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, float v_speed, IntPtr v_min, IntPtr v_max)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
-            }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_v, v_speed, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, float v_speed, IntPtr v_min, IntPtr v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5209,9 +5893,6 @@ public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, f
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -5230,19 +5911,22 @@ public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, f
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_v, v_speed, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            fixed (Vector2* native_v = &v)
             {
-                Util.Free(native_format);
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, float v_speed, IntPtr v_min, IntPtr v_max, string format, float power)
+#endif
+        public static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5262,9 +5946,6 @@ public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, f
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -5283,50 +5964,22 @@ public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr v, f
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_v, v_speed, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_format);
-            }
-            return ret != 0;
-        }
-        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, float v_speed)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            fixed (Vector2* native_v = &v)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                byte ret = ImGuiNative.igDragFloat2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
-            }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* v_min = null;
-            void* v_max = null;
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_v, components, v_speed, v_min, v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, float v_speed, IntPtr v_min)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5346,19 +5999,40 @@ public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* v_max = null;
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_v, components, v_speed, native_v_min, v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, float v_speed, IntPtr v_min, IntPtr v_max)
+#endif
+        public static bool DragFloat3(string label, ref Vector3 v)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5378,19 +6052,40 @@ public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_v, components, v_speed, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, float v_speed, IntPtr v_min, IntPtr v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5410,14 +6105,11 @@ public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -5427,23 +6119,25 @@ public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v,
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_v, components, v_speed, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
             {
-                Util.Free(native_format);
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, float v_speed, IntPtr v_min, IntPtr v_max, string format, float power)
+#endif
+        public static bool DragFloat3(string label, ref Vector3 v, float v_speed)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -5463,14 +6157,11 @@ public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
+            float v_min = 0.0f;
+            float v_max = 0.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -5480,880 +6171,15892 @@ public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr v,
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_v, components, v_speed, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed, float v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed, float v_min, float v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat4(string label, ref Vector4 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat4(string label, ref Vector4 v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed, float v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed, float v_min, float v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragFloat4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_min = 0.0f;
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_max = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ReadOnlySpan<char> format_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format, string format_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ReadOnlySpan<char> format_max, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format, string format_max, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            fixed (float* native_v_current_min = &v_current_min)
+            {
+                fixed (float* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragFloatRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt(string label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt(string label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt2(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt2(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt2(string label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt2(string label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt2(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt3(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt3(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt3(string label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt3(string label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt3(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt4(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt4(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt4(string label, ref int v, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt4(string label, ref int v, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igDragInt4(native_label, native_v, v_speed, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float v_speed = 1.0f;
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_min = 0;
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int v_max = 0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ReadOnlySpan<char> format_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format, string format_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ReadOnlySpan<char> format_max, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format, string format_max, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte* native_format_max;
+            int format_max_byteCount = 0;
+            if (format_max != null)
+            {
+                format_max_byteCount = Encoding.UTF8.GetByteCount(format_max);
+                if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format_max = Util.Allocate(format_max_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_max_stackBytes = stackalloc byte[format_max_byteCount + 1];
+                    native_format_max = native_format_max_stackBytes;
+                }
+                int native_format_max_offset = Util.GetUtf8(format_max, native_format_max, format_max_byteCount);
+                native_format_max[native_format_max_offset] = 0;
+            }
+            else { native_format_max = null; }
+            fixed (int* native_v_current_min = &v_current_min)
+            {
+                fixed (int* native_v_current_max = &v_current_max)
+                {
+                    byte ret = ImGuiNative.igDragIntRange2(native_label, native_v_current_min, native_v_current_max, v_speed, v_min, v_max, native_format, native_format_max, flags);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    if (format_max_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format_max);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            float v_speed = 1.0f;
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            float v_speed = 1.0f;
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igDragScalar(native_label, data_type, native_p_data, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            float v_speed = 1.0f;
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            float v_speed = 1.0f;
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_min = null;
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* p_max = null;
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igDragScalarN(native_label, data_type, native_p_data, components, v_speed, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+        public static void Dummy(Vector2 size)
+        {
+            ImGuiNative.igDummy(size);
+        }
+        public static void End()
+        {
+            ImGuiNative.igEnd();
+        }
+        public static void EndChild()
+        {
+            ImGuiNative.igEndChild();
+        }
+        public static void EndCombo()
+        {
+            ImGuiNative.igEndCombo();
+        }
+        public static void EndDisabled()
+        {
+            ImGuiNative.igEndDisabled();
+        }
+        public static void EndDragDropSource()
+        {
+            ImGuiNative.igEndDragDropSource();
+        }
+        public static void EndDragDropTarget()
+        {
+            ImGuiNative.igEndDragDropTarget();
+        }
+        public static void EndFrame()
+        {
+            ImGuiNative.igEndFrame();
+        }
+        public static void EndGroup()
+        {
+            ImGuiNative.igEndGroup();
+        }
+        public static void EndListBox()
+        {
+            ImGuiNative.igEndListBox();
+        }
+        public static void EndMainMenuBar()
+        {
+            ImGuiNative.igEndMainMenuBar();
+        }
+        public static void EndMenu()
+        {
+            ImGuiNative.igEndMenu();
+        }
+        public static void EndMenuBar()
+        {
+            ImGuiNative.igEndMenuBar();
+        }
+        public static ImGuiMultiSelectIOPtr EndMultiSelect()
+        {
+            ImGuiMultiSelectIO* ret = ImGuiNative.igEndMultiSelect();
+            return new ImGuiMultiSelectIOPtr(ret);
+        }
+        public static void EndPopup()
+        {
+            ImGuiNative.igEndPopup();
+        }
+        public static void EndTabBar()
+        {
+            ImGuiNative.igEndTabBar();
+        }
+        public static void EndTabItem()
+        {
+            ImGuiNative.igEndTabItem();
+        }
+        public static void EndTable()
+        {
+            ImGuiNative.igEndTable();
+        }
+        public static void EndTooltip()
+        {
+            ImGuiNative.igEndTooltip();
+        }
+        public static ImGuiViewportPtr FindViewportByID(uint id)
+        {
+            ImGuiViewport* ret = ImGuiNative.igFindViewportByID(id);
+            return new ImGuiViewportPtr(ret);
+        }
+        public static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platform_handle)
+        {
+            void* native_platform_handle = (void*)platform_handle.ToPointer();
+            ImGuiViewport* ret = ImGuiNative.igFindViewportByPlatformHandle(native_platform_handle);
+            return new ImGuiViewportPtr(ret);
+        }
+        public static void GetAllocatorFunctions(ref IntPtr p_alloc_func, ref IntPtr p_free_func, ref void* p_user_data)
+        {
+            fixed (IntPtr* native_p_alloc_func = &p_alloc_func)
+            {
+                fixed (IntPtr* native_p_free_func = &p_free_func)
+                {
+                    fixed (void** native_p_user_data = &p_user_data)
+                    {
+                        ImGuiNative.igGetAllocatorFunctions(native_p_alloc_func, native_p_free_func, native_p_user_data);
+                    }
+                }
+            }
+        }
+        public static ImDrawListPtr GetBackgroundDrawList()
+        {
+            ImGuiViewport* viewport = null;
+            ImDrawList* ret = ImGuiNative.igGetBackgroundDrawList(viewport);
+            return new ImDrawListPtr(ret);
+        }
+        public static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
+        {
+            ImGuiViewport* native_viewport = viewport.NativePtr;
+            ImDrawList* ret = ImGuiNative.igGetBackgroundDrawList(native_viewport);
+            return new ImDrawListPtr(ret);
+        }
+        public static string GetClipboardText()
+        {
+            byte* ret = ImGuiNative.igGetClipboardText();
+            return Util.StringFromPtr(ret);
+        }
+        public static uint GetColorU32(ImGuiCol idx)
+        {
+            float alpha_mul = 1.0f;
+            uint ret = ImGuiNative.igGetColorU32_Col(idx, alpha_mul);
+            return ret;
+        }
+        public static uint GetColorU32(ImGuiCol idx, float alpha_mul)
+        {
+            uint ret = ImGuiNative.igGetColorU32_Col(idx, alpha_mul);
+            return ret;
+        }
+        public static uint GetColorU32(Vector4 col)
+        {
+            uint ret = ImGuiNative.igGetColorU32_Vec4(col);
+            return ret;
+        }
+        public static uint GetColorU32(uint col)
+        {
+            float alpha_mul = 1.0f;
+            uint ret = ImGuiNative.igGetColorU32_U32(col, alpha_mul);
+            return ret;
+        }
+        public static uint GetColorU32(uint col, float alpha_mul)
+        {
+            uint ret = ImGuiNative.igGetColorU32_U32(col, alpha_mul);
+            return ret;
+        }
+        public static int GetColumnIndex()
+        {
+            int ret = ImGuiNative.igGetColumnIndex();
+            return ret;
+        }
+        public static float GetColumnOffset()
+        {
+            int column_index = -1;
+            float ret = ImGuiNative.igGetColumnOffset(column_index);
+            return ret;
+        }
+        public static float GetColumnOffset(int column_index)
+        {
+            float ret = ImGuiNative.igGetColumnOffset(column_index);
+            return ret;
+        }
+        public static int GetColumnsCount()
+        {
+            int ret = ImGuiNative.igGetColumnsCount();
+            return ret;
+        }
+        public static float GetColumnWidth()
+        {
+            int column_index = -1;
+            float ret = ImGuiNative.igGetColumnWidth(column_index);
+            return ret;
+        }
+        public static float GetColumnWidth(int column_index)
+        {
+            float ret = ImGuiNative.igGetColumnWidth(column_index);
+            return ret;
+        }
+        public static Vector2 GetContentRegionAvail()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetContentRegionAvail(&__retval);
+            return __retval;
+        }
+        public static IntPtr GetCurrentContext()
+        {
+            IntPtr ret = ImGuiNative.igGetCurrentContext();
+            return ret;
+        }
+        public static Vector2 GetCursorPos()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetCursorPos(&__retval);
+            return __retval;
+        }
+        public static float GetCursorPosX()
+        {
+            float ret = ImGuiNative.igGetCursorPosX();
+            return ret;
+        }
+        public static float GetCursorPosY()
+        {
+            float ret = ImGuiNative.igGetCursorPosY();
+            return ret;
+        }
+        public static Vector2 GetCursorScreenPos()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetCursorScreenPos(&__retval);
+            return __retval;
+        }
+        public static Vector2 GetCursorStartPos()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetCursorStartPos(&__retval);
+            return __retval;
+        }
+        public static ImGuiPayloadPtr GetDragDropPayload()
+        {
+            ImGuiPayload* ret = ImGuiNative.igGetDragDropPayload();
+            return new ImGuiPayloadPtr(ret);
+        }
+        public static ImDrawDataPtr GetDrawData()
+        {
+            ImDrawData* ret = ImGuiNative.igGetDrawData();
+            return new ImDrawDataPtr(ret);
+        }
+        public static IntPtr GetDrawListSharedData()
+        {
+            IntPtr ret = ImGuiNative.igGetDrawListSharedData();
+            return ret;
+        }
+        public static ImFontPtr GetFont()
+        {
+            ImFont* ret = ImGuiNative.igGetFont();
+            return new ImFontPtr(ret);
+        }
+        public static float GetFontSize()
+        {
+            float ret = ImGuiNative.igGetFontSize();
+            return ret;
+        }
+        public static Vector2 GetFontTexUvWhitePixel()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetFontTexUvWhitePixel(&__retval);
+            return __retval;
+        }
+        public static ImDrawListPtr GetForegroundDrawList()
+        {
+            ImGuiViewport* viewport = null;
+            ImDrawList* ret = ImGuiNative.igGetForegroundDrawList_ViewportPtr(viewport);
+            return new ImDrawListPtr(ret);
+        }
+        public static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
+        {
+            ImGuiViewport* native_viewport = viewport.NativePtr;
+            ImDrawList* ret = ImGuiNative.igGetForegroundDrawList_ViewportPtr(native_viewport);
+            return new ImDrawListPtr(ret);
+        }
+        public static int GetFrameCount()
+        {
+            int ret = ImGuiNative.igGetFrameCount();
+            return ret;
+        }
+        public static float GetFrameHeight()
+        {
+            float ret = ImGuiNative.igGetFrameHeight();
+            return ret;
+        }
+        public static float GetFrameHeightWithSpacing()
+        {
+            float ret = ImGuiNative.igGetFrameHeightWithSpacing();
+            return ret;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static uint GetID(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            uint ret = ImGuiNative.igGetID_Str(native_str_id);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret;
+        }
+#endif
+        public static uint GetID(string str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            uint ret = ImGuiNative.igGetID_Str(native_str_id);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret;
+        }
+        public static uint GetID(IntPtr ptr_id)
+        {
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            uint ret = ImGuiNative.igGetID_Ptr(native_ptr_id);
+            return ret;
+        }
+        public static uint GetID(int int_id)
+        {
+            uint ret = ImGuiNative.igGetID_Int(int_id);
+            return ret;
+        }
+        public static ImGuiIOPtr GetIO()
+        {
+            ImGuiIO* ret = ImGuiNative.igGetIO();
+            return new ImGuiIOPtr(ret);
+        }
+        public static uint GetItemID()
+        {
+            uint ret = ImGuiNative.igGetItemID();
+            return ret;
+        }
+        public static Vector2 GetItemRectMax()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetItemRectMax(&__retval);
+            return __retval;
+        }
+        public static Vector2 GetItemRectMin()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetItemRectMin(&__retval);
+            return __retval;
+        }
+        public static Vector2 GetItemRectSize()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetItemRectSize(&__retval);
+            return __retval;
+        }
+        public static string GetKeyName(ImGuiKey key)
+        {
+            byte* ret = ImGuiNative.igGetKeyName(key);
+            return Util.StringFromPtr(ret);
+        }
+        public static int GetKeyPressedAmount(ImGuiKey key, float repeat_delay, float rate)
+        {
+            int ret = ImGuiNative.igGetKeyPressedAmount(key, repeat_delay, rate);
+            return ret;
+        }
+        public static ImGuiViewportPtr GetMainViewport()
+        {
+            ImGuiViewport* ret = ImGuiNative.igGetMainViewport();
+            return new ImGuiViewportPtr(ret);
+        }
+        public static int GetMouseClickedCount(ImGuiMouseButton button)
+        {
+            int ret = ImGuiNative.igGetMouseClickedCount(button);
+            return ret;
+        }
+        public static ImGuiMouseCursor GetMouseCursor()
+        {
+            ImGuiMouseCursor ret = ImGuiNative.igGetMouseCursor();
+            return ret;
+        }
+        public static Vector2 GetMouseDragDelta()
+        {
+            Vector2 __retval;
+            ImGuiMouseButton button = (ImGuiMouseButton)0;
+            float lock_threshold = -1.0f;
+            ImGuiNative.igGetMouseDragDelta(&__retval, button, lock_threshold);
+            return __retval;
+        }
+        public static Vector2 GetMouseDragDelta(ImGuiMouseButton button)
+        {
+            Vector2 __retval;
+            float lock_threshold = -1.0f;
+            ImGuiNative.igGetMouseDragDelta(&__retval, button, lock_threshold);
+            return __retval;
+        }
+        public static Vector2 GetMouseDragDelta(ImGuiMouseButton button, float lock_threshold)
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetMouseDragDelta(&__retval, button, lock_threshold);
+            return __retval;
+        }
+        public static Vector2 GetMousePos()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetMousePos(&__retval);
+            return __retval;
+        }
+        public static Vector2 GetMousePosOnOpeningCurrentPopup()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetMousePosOnOpeningCurrentPopup(&__retval);
+            return __retval;
+        }
+        public static ImGuiPlatformIOPtr GetPlatformIO()
+        {
+            ImGuiPlatformIO* ret = ImGuiNative.igGetPlatformIO();
+            return new ImGuiPlatformIOPtr(ret);
+        }
+        public static float GetScrollMaxX()
+        {
+            float ret = ImGuiNative.igGetScrollMaxX();
+            return ret;
+        }
+        public static float GetScrollMaxY()
+        {
+            float ret = ImGuiNative.igGetScrollMaxY();
+            return ret;
+        }
+        public static float GetScrollX()
+        {
+            float ret = ImGuiNative.igGetScrollX();
+            return ret;
+        }
+        public static float GetScrollY()
+        {
+            float ret = ImGuiNative.igGetScrollY();
+            return ret;
+        }
+        public static ImGuiStoragePtr GetStateStorage()
+        {
+            ImGuiStorage* ret = ImGuiNative.igGetStateStorage();
+            return new ImGuiStoragePtr(ret);
+        }
+        public static ImGuiStylePtr GetStyle()
+        {
+            ImGuiStyle* ret = ImGuiNative.igGetStyle();
+            return new ImGuiStylePtr(ret);
+        }
+        public static string GetStyleColorName(ImGuiCol idx)
+        {
+            byte* ret = ImGuiNative.igGetStyleColorName(idx);
+            return Util.StringFromPtr(ret);
+        }
+        public static Vector4* GetStyleColorVec4(ImGuiCol idx)
+        {
+            Vector4* ret = ImGuiNative.igGetStyleColorVec4(idx);
+            return ret;
+        }
+        public static float GetTextLineHeight()
+        {
+            float ret = ImGuiNative.igGetTextLineHeight();
+            return ret;
+        }
+        public static float GetTextLineHeightWithSpacing()
+        {
+            float ret = ImGuiNative.igGetTextLineHeightWithSpacing();
+            return ret;
+        }
+        public static double GetTime()
+        {
+            double ret = ImGuiNative.igGetTime();
+            return ret;
+        }
+        public static float GetTreeNodeToLabelSpacing()
+        {
+            float ret = ImGuiNative.igGetTreeNodeToLabelSpacing();
+            return ret;
+        }
+        public static string GetVersion()
+        {
+            byte* ret = ImGuiNative.igGetVersion();
+            return Util.StringFromPtr(ret);
+        }
+        public static uint GetWindowDockID()
+        {
+            uint ret = ImGuiNative.igGetWindowDockID();
+            return ret;
+        }
+        public static float GetWindowDpiScale()
+        {
+            float ret = ImGuiNative.igGetWindowDpiScale();
+            return ret;
+        }
+        public static ImDrawListPtr GetWindowDrawList()
+        {
+            ImDrawList* ret = ImGuiNative.igGetWindowDrawList();
+            return new ImDrawListPtr(ret);
+        }
+        public static float GetWindowHeight()
+        {
+            float ret = ImGuiNative.igGetWindowHeight();
+            return ret;
+        }
+        public static Vector2 GetWindowPos()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetWindowPos(&__retval);
+            return __retval;
+        }
+        public static Vector2 GetWindowSize()
+        {
+            Vector2 __retval;
+            ImGuiNative.igGetWindowSize(&__retval);
+            return __retval;
+        }
+        public static ImGuiViewportPtr GetWindowViewport()
+        {
+            ImGuiViewport* ret = ImGuiNative.igGetWindowViewport();
+            return new ImGuiViewportPtr(ret);
+        }
+        public static float GetWindowWidth()
+        {
+            float ret = ImGuiNative.igGetWindowWidth();
+            return ret;
+        }
+        public static void Image(IntPtr user_texture_id, Vector2 image_size)
+        {
+            Vector2 uv0 = new Vector2();
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            Vector4 border_col = new Vector4();
+            ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, border_col);
+        }
+        public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0)
+        {
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            Vector4 border_col = new Vector4();
+            ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, border_col);
+        }
+        public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1)
+        {
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            Vector4 border_col = new Vector4();
+            ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, border_col);
+        }
+        public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 tint_col)
+        {
+            Vector4 border_col = new Vector4();
+            ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, border_col);
+        }
+        public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col)
+        {
+            ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, border_col);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector2 uv0 = new Vector2();
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 bg_col = new Vector4();
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector2 uv0 = new Vector2();
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 bg_col = new Vector4();
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 bg_col = new Vector4();
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 bg_col = new Vector4();
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector4 bg_col = new Vector4();
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector4 bg_col = new Vector4();
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igImageButton(native_str_id, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+        public static void Indent()
+        {
+            float indent_w = 0.0f;
+            ImGuiNative.igIndent(indent_w);
+        }
+        public static void Indent(float indent_w)
+        {
+            ImGuiNative.igIndent(indent_w);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputDouble(ReadOnlySpan<char> label, ref double v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            double step = 0.0;
+            double step_fast = 0.0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputDouble(string label, ref double v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            double step = 0.0;
+            double step_fast = 0.0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            double step_fast = 0.0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputDouble(string label, ref double v, double step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            double step_fast = 0.0;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step, double step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputDouble(string label, ref double v, double step, double step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step, double step_fast, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputDouble(string label, ref double v, double step, double step_fast, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step, double step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputDouble(string label, ref double v, double step, double step_fast, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (double* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat(ReadOnlySpan<char> label, ref float v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float step = 0.0f;
+            float step_fast = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat(string label, ref float v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float step = 0.0f;
+            float step_fast = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float step_fast = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat(string label, ref float v, float step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float step_fast = 0.0f;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step, float step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat(string label, ref float v, float step, float step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step, float step_fast, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat(string label, ref float v, float step, float step_fast, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step, float step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat(string label, ref float v, float step, float step_fast, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat2(ReadOnlySpan<char> label, ref Vector2 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector2* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat2(string label, ref Vector2 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector2* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat2(ReadOnlySpan<char> label, ref Vector2 v, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector2* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat2(string label, ref Vector2 v, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector2* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat2(ReadOnlySpan<char> label, ref Vector2 v, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector2* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat2(string label, ref Vector2 v, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector2* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat3(ReadOnlySpan<char> label, ref Vector3 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat3(string label, ref Vector3 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat3(ReadOnlySpan<char> label, ref Vector3 v, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat3(string label, ref Vector3 v, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat3(ReadOnlySpan<char> label, ref Vector3 v, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat3(string label, ref Vector3 v, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat4(ReadOnlySpan<char> label, ref Vector4 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat4(string label, ref Vector4 v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat4(ReadOnlySpan<char> label, ref Vector4 v, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat4(string label, ref Vector4 v, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputFloat4(ReadOnlySpan<char> label, ref Vector4 v, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputFloat4(string label, ref Vector4 v, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int step = 1;
+            int step_fast = 100;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int step = 1;
+            int step_fast = 100;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt(ReadOnlySpan<char> label, ref int v, int step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int step_fast = 100;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt(string label, ref int v, int step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int step_fast = 100;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt(ReadOnlySpan<char> label, ref int v, int step, int step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt(string label, ref int v, int step, int step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt(ReadOnlySpan<char> label, ref int v, int step, int step_fast, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt(string label, ref int v, int step, int step_fast, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt2(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt2(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt2(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt2(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt2(ReadOnlySpan<char> label, ref int v, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt2(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt2(string label, ref int v, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt2(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt3(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt3(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt3(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt3(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt3(ReadOnlySpan<char> label, ref int v, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt3(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt3(string label, ref int v, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt3(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt4(ReadOnlySpan<char> label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt4(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt4(string label, ref int v)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt4(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputInt4(ReadOnlySpan<char> label, ref int v, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt4(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool InputInt4(string label, ref int v, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igInputInt4(native_label, native_v, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_step = null;
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_step = null;
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_p_data, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_step = null;
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* p_step = null;
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* p_step_fast = null;
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format = null;
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiInputTextFlags flags = (ImGuiInputTextFlags)0;
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, string format, ImGuiInputTextFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_step = (void*)p_step.ToPointer();
+            void* native_p_step_fast = (void*)p_step_fast.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_p_data, components, native_p_step, native_p_step_fast, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InvisibleButton(ReadOnlySpan<char> str_id, Vector2 size)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiButtonFlags flags = (ImGuiButtonFlags)0;
+            byte ret = ImGuiNative.igInvisibleButton(native_str_id, size, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InvisibleButton(string str_id, Vector2 size)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiButtonFlags flags = (ImGuiButtonFlags)0;
+            byte ret = ImGuiNative.igInvisibleButton(native_str_id, size, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool InvisibleButton(ReadOnlySpan<char> str_id, Vector2 size, ImGuiButtonFlags flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igInvisibleButton(native_str_id, size, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool InvisibleButton(string str_id, Vector2 size, ImGuiButtonFlags flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igInvisibleButton(native_str_id, size, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+        public static bool IsAnyItemActive()
+        {
+            byte ret = ImGuiNative.igIsAnyItemActive();
+            return ret != 0;
+        }
+        public static bool IsAnyItemFocused()
+        {
+            byte ret = ImGuiNative.igIsAnyItemFocused();
+            return ret != 0;
+        }
+        public static bool IsAnyItemHovered()
+        {
+            byte ret = ImGuiNative.igIsAnyItemHovered();
+            return ret != 0;
+        }
+        public static bool IsAnyMouseDown()
+        {
+            byte ret = ImGuiNative.igIsAnyMouseDown();
+            return ret != 0;
+        }
+        public static bool IsItemActivated()
+        {
+            byte ret = ImGuiNative.igIsItemActivated();
+            return ret != 0;
+        }
+        public static bool IsItemActive()
+        {
+            byte ret = ImGuiNative.igIsItemActive();
+            return ret != 0;
+        }
+        public static bool IsItemClicked()
+        {
+            ImGuiMouseButton mouse_button = (ImGuiMouseButton)0;
+            byte ret = ImGuiNative.igIsItemClicked(mouse_button);
+            return ret != 0;
+        }
+        public static bool IsItemClicked(ImGuiMouseButton mouse_button)
+        {
+            byte ret = ImGuiNative.igIsItemClicked(mouse_button);
+            return ret != 0;
+        }
+        public static bool IsItemDeactivated()
+        {
+            byte ret = ImGuiNative.igIsItemDeactivated();
+            return ret != 0;
+        }
+        public static bool IsItemDeactivatedAfterEdit()
+        {
+            byte ret = ImGuiNative.igIsItemDeactivatedAfterEdit();
+            return ret != 0;
+        }
+        public static bool IsItemEdited()
+        {
+            byte ret = ImGuiNative.igIsItemEdited();
+            return ret != 0;
+        }
+        public static bool IsItemFocused()
+        {
+            byte ret = ImGuiNative.igIsItemFocused();
+            return ret != 0;
+        }
+        public static bool IsItemHovered()
+        {
+            ImGuiHoveredFlags flags = (ImGuiHoveredFlags)0;
+            byte ret = ImGuiNative.igIsItemHovered(flags);
+            return ret != 0;
+        }
+        public static bool IsItemHovered(ImGuiHoveredFlags flags)
+        {
+            byte ret = ImGuiNative.igIsItemHovered(flags);
+            return ret != 0;
+        }
+        public static bool IsItemToggledOpen()
+        {
+            byte ret = ImGuiNative.igIsItemToggledOpen();
+            return ret != 0;
+        }
+        public static bool IsItemToggledSelection()
+        {
+            byte ret = ImGuiNative.igIsItemToggledSelection();
+            return ret != 0;
+        }
+        public static bool IsItemVisible()
+        {
+            byte ret = ImGuiNative.igIsItemVisible();
+            return ret != 0;
+        }
+        public static bool IsKeyChordPressed(ImGuiKey key_chord)
+        {
+            byte ret = ImGuiNative.igIsKeyChordPressed_Nil(key_chord);
+            return ret != 0;
+        }
+        public static bool IsKeyDown(ImGuiKey key)
+        {
+            byte ret = ImGuiNative.igIsKeyDown_Nil(key);
+            return ret != 0;
+        }
+        public static bool IsKeyPressed(ImGuiKey key)
+        {
+            byte repeat = 1;
+            byte ret = ImGuiNative.igIsKeyPressed_Bool(key, repeat);
+            return ret != 0;
+        }
+        public static bool IsKeyPressed(ImGuiKey key, bool repeat)
+        {
+            byte native_repeat = repeat ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igIsKeyPressed_Bool(key, native_repeat);
+            return ret != 0;
+        }
+        public static bool IsKeyReleased(ImGuiKey key)
+        {
+            byte ret = ImGuiNative.igIsKeyReleased_Nil(key);
+            return ret != 0;
+        }
+        public static bool IsMouseClicked(ImGuiMouseButton button)
+        {
+            byte repeat = 0;
+            byte ret = ImGuiNative.igIsMouseClicked_Bool(button, repeat);
+            return ret != 0;
+        }
+        public static bool IsMouseClicked(ImGuiMouseButton button, bool repeat)
+        {
+            byte native_repeat = repeat ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igIsMouseClicked_Bool(button, native_repeat);
+            return ret != 0;
+        }
+        public static bool IsMouseDoubleClicked(ImGuiMouseButton button)
+        {
+            byte ret = ImGuiNative.igIsMouseDoubleClicked_Nil(button);
+            return ret != 0;
+        }
+        public static bool IsMouseDown(ImGuiMouseButton button)
+        {
+            byte ret = ImGuiNative.igIsMouseDown_Nil(button);
+            return ret != 0;
+        }
+        public static bool IsMouseDragging(ImGuiMouseButton button)
+        {
+            float lock_threshold = -1.0f;
+            byte ret = ImGuiNative.igIsMouseDragging(button, lock_threshold);
+            return ret != 0;
+        }
+        public static bool IsMouseDragging(ImGuiMouseButton button, float lock_threshold)
+        {
+            byte ret = ImGuiNative.igIsMouseDragging(button, lock_threshold);
+            return ret != 0;
+        }
+        public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max)
+        {
+            byte clip = 1;
+            byte ret = ImGuiNative.igIsMouseHoveringRect(r_min, r_max, clip);
+            return ret != 0;
+        }
+        public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max, bool clip)
+        {
+            byte native_clip = clip ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igIsMouseHoveringRect(r_min, r_max, native_clip);
+            return ret != 0;
+        }
+        public static bool IsMousePosValid()
+        {
+            Vector2* mouse_pos = null;
+            byte ret = ImGuiNative.igIsMousePosValid(mouse_pos);
+            return ret != 0;
+        }
+        public static bool IsMousePosValid(ref Vector2 mouse_pos)
+        {
+            fixed (Vector2* native_mouse_pos = &mouse_pos)
+            {
+                byte ret = ImGuiNative.igIsMousePosValid(native_mouse_pos);
+                return ret != 0;
+            }
+        }
+        public static bool IsMouseReleased(ImGuiMouseButton button)
+        {
+            byte ret = ImGuiNative.igIsMouseReleased_Nil(button);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool IsPopupOpen(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiPopupFlags flags = (ImGuiPopupFlags)0;
+            byte ret = ImGuiNative.igIsPopupOpen_Str(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool IsPopupOpen(string str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiPopupFlags flags = (ImGuiPopupFlags)0;
+            byte ret = ImGuiNative.igIsPopupOpen_Str(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool IsPopupOpen(ReadOnlySpan<char> str_id, ImGuiPopupFlags flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igIsPopupOpen_Str(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool IsPopupOpen(string str_id, ImGuiPopupFlags flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            byte ret = ImGuiNative.igIsPopupOpen_Str(native_str_id, flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            return ret != 0;
+        }
+        public static bool IsRectVisible(Vector2 size)
+        {
+            byte ret = ImGuiNative.igIsRectVisible_Nil(size);
+            return ret != 0;
+        }
+        public static bool IsRectVisible(Vector2 rect_min, Vector2 rect_max)
+        {
+            byte ret = ImGuiNative.igIsRectVisible_Vec2(rect_min, rect_max);
+            return ret != 0;
+        }
+        public static bool IsWindowAppearing()
+        {
+            byte ret = ImGuiNative.igIsWindowAppearing();
+            return ret != 0;
+        }
+        public static bool IsWindowCollapsed()
+        {
+            byte ret = ImGuiNative.igIsWindowCollapsed();
+            return ret != 0;
+        }
+        public static bool IsWindowDocked()
+        {
+            byte ret = ImGuiNative.igIsWindowDocked();
+            return ret != 0;
+        }
+        public static bool IsWindowFocused()
+        {
+            ImGuiFocusedFlags flags = (ImGuiFocusedFlags)0;
+            byte ret = ImGuiNative.igIsWindowFocused(flags);
+            return ret != 0;
+        }
+        public static bool IsWindowFocused(ImGuiFocusedFlags flags)
+        {
+            byte ret = ImGuiNative.igIsWindowFocused(flags);
+            return ret != 0;
+        }
+        public static bool IsWindowHovered()
+        {
+            ImGuiHoveredFlags flags = (ImGuiHoveredFlags)0;
+            byte ret = ImGuiNative.igIsWindowHovered(flags);
+            return ret != 0;
+        }
+        public static bool IsWindowHovered(ImGuiHoveredFlags flags)
+        {
+            byte ret = ImGuiNative.igIsWindowHovered(flags);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LabelText(ReadOnlySpan<char> label, ReadOnlySpan<char> fmt)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igLabelText(native_label, native_fmt);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void LabelText(string label, string fmt)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igLabelText(native_label, native_fmt);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ListBox(ReadOnlySpan<char> label, ref int current_item, string[] items, int items_count)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
+            }
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
+            }
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            int height_in_items = -1;
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igListBox_Str_arr(native_label, native_current_item, native_items, items_count, height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool ListBox(string label, ref int current_item, string[] items, int items_count)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
+            }
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
+            }
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            int height_in_items = -1;
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igListBox_Str_arr(native_label, native_current_item, native_items, items_count, height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ListBox(ReadOnlySpan<char> label, ref int current_item, string[] items, int items_count, int height_in_items)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
+            }
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
+            }
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igListBox_Str_arr(native_label, native_current_item, native_items, items_count, height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool ListBox(string label, ref int current_item, string[] items, int items_count, int height_in_items)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int* items_byteCounts = stackalloc int[items.Length];
+            int items_byteCount = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                items_byteCount += items_byteCounts[i] + 1;
+            }
+            byte* native_items_data = stackalloc byte[items_byteCount];
+            int offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                string s = items[i];
+                offset += Util.GetUtf8(s, native_items_data + offset, items_byteCounts[i]);
+                native_items_data[offset++] = 0;
+            }
+            byte** native_items = stackalloc byte*[items.Length];
+            offset = 0;
+            for (int i = 0; i < items.Length; i++)
+            {
+                native_items[i] = &native_items_data[offset];
+                offset += items_byteCounts[i] + 1;
+            }
+            fixed (int* native_current_item = &current_item)
+            {
+                byte ret = ImGuiNative.igListBox_Str_arr(native_label, native_current_item, native_items, items_count, height_in_items);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadIniSettingsFromDisk(ReadOnlySpan<char> ini_filename)
+        {
+            byte* native_ini_filename;
+            int ini_filename_byteCount = 0;
+            if (ini_filename != null)
+            {
+                ini_filename_byteCount = Encoding.UTF8.GetByteCount(ini_filename);
+                if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_filename = Util.Allocate(ini_filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_filename_stackBytes = stackalloc byte[ini_filename_byteCount + 1];
+                    native_ini_filename = native_ini_filename_stackBytes;
+                }
+                int native_ini_filename_offset = Util.GetUtf8(ini_filename, native_ini_filename, ini_filename_byteCount);
+                native_ini_filename[native_ini_filename_offset] = 0;
+            }
+            else { native_ini_filename = null; }
+            ImGuiNative.igLoadIniSettingsFromDisk(native_ini_filename);
+            if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_filename);
+            }
+        }
+#endif
+        public static void LoadIniSettingsFromDisk(string ini_filename)
+        {
+            byte* native_ini_filename;
+            int ini_filename_byteCount = 0;
+            if (ini_filename != null)
+            {
+                ini_filename_byteCount = Encoding.UTF8.GetByteCount(ini_filename);
+                if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_filename = Util.Allocate(ini_filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_filename_stackBytes = stackalloc byte[ini_filename_byteCount + 1];
+                    native_ini_filename = native_ini_filename_stackBytes;
+                }
+                int native_ini_filename_offset = Util.GetUtf8(ini_filename, native_ini_filename, ini_filename_byteCount);
+                native_ini_filename[native_ini_filename_offset] = 0;
+            }
+            else { native_ini_filename = null; }
+            ImGuiNative.igLoadIniSettingsFromDisk(native_ini_filename);
+            if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_filename);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadIniSettingsFromMemory(ReadOnlySpan<char> ini_data)
+        {
+            byte* native_ini_data;
+            int ini_data_byteCount = 0;
+            if (ini_data != null)
+            {
+                ini_data_byteCount = Encoding.UTF8.GetByteCount(ini_data);
+                if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_data = Util.Allocate(ini_data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_data_stackBytes = stackalloc byte[ini_data_byteCount + 1];
+                    native_ini_data = native_ini_data_stackBytes;
+                }
+                int native_ini_data_offset = Util.GetUtf8(ini_data, native_ini_data, ini_data_byteCount);
+                native_ini_data[native_ini_data_offset] = 0;
+            }
+            else { native_ini_data = null; }
+            uint ini_size = 0;
+            ImGuiNative.igLoadIniSettingsFromMemory(native_ini_data, ini_size);
+            if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_data);
+            }
+        }
+#endif
+        public static void LoadIniSettingsFromMemory(string ini_data)
+        {
+            byte* native_ini_data;
+            int ini_data_byteCount = 0;
+            if (ini_data != null)
+            {
+                ini_data_byteCount = Encoding.UTF8.GetByteCount(ini_data);
+                if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_data = Util.Allocate(ini_data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_data_stackBytes = stackalloc byte[ini_data_byteCount + 1];
+                    native_ini_data = native_ini_data_stackBytes;
+                }
+                int native_ini_data_offset = Util.GetUtf8(ini_data, native_ini_data, ini_data_byteCount);
+                native_ini_data[native_ini_data_offset] = 0;
+            }
+            else { native_ini_data = null; }
+            uint ini_size = 0;
+            ImGuiNative.igLoadIniSettingsFromMemory(native_ini_data, ini_size);
+            if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_data);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadIniSettingsFromMemory(ReadOnlySpan<char> ini_data, uint ini_size)
+        {
+            byte* native_ini_data;
+            int ini_data_byteCount = 0;
+            if (ini_data != null)
+            {
+                ini_data_byteCount = Encoding.UTF8.GetByteCount(ini_data);
+                if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_data = Util.Allocate(ini_data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_data_stackBytes = stackalloc byte[ini_data_byteCount + 1];
+                    native_ini_data = native_ini_data_stackBytes;
+                }
+                int native_ini_data_offset = Util.GetUtf8(ini_data, native_ini_data, ini_data_byteCount);
+                native_ini_data[native_ini_data_offset] = 0;
+            }
+            else { native_ini_data = null; }
+            ImGuiNative.igLoadIniSettingsFromMemory(native_ini_data, ini_size);
+            if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_data);
+            }
+        }
+#endif
+        public static void LoadIniSettingsFromMemory(string ini_data, uint ini_size)
+        {
+            byte* native_ini_data;
+            int ini_data_byteCount = 0;
+            if (ini_data != null)
+            {
+                ini_data_byteCount = Encoding.UTF8.GetByteCount(ini_data);
+                if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_data = Util.Allocate(ini_data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_data_stackBytes = stackalloc byte[ini_data_byteCount + 1];
+                    native_ini_data = native_ini_data_stackBytes;
+                }
+                int native_ini_data_offset = Util.GetUtf8(ini_data, native_ini_data, ini_data_byteCount);
+                native_ini_data[native_ini_data_offset] = 0;
+            }
+            else { native_ini_data = null; }
+            ImGuiNative.igLoadIniSettingsFromMemory(native_ini_data, ini_size);
+            if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_data);
+            }
+        }
+        public static void LogButtons()
+        {
+            ImGuiNative.igLogButtons();
+        }
+        public static void LogFinish()
+        {
+            ImGuiNative.igLogFinish();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LogText(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igLogText(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void LogText(string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igLogText(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+        public static void LogToClipboard()
+        {
+            int auto_open_depth = -1;
+            ImGuiNative.igLogToClipboard(auto_open_depth);
+        }
+        public static void LogToClipboard(int auto_open_depth)
+        {
+            ImGuiNative.igLogToClipboard(auto_open_depth);
+        }
+        public static void LogToFile()
+        {
+            int auto_open_depth = -1;
+            byte* native_filename = null;
+            ImGuiNative.igLogToFile(auto_open_depth, native_filename);
+        }
+        public static void LogToFile(int auto_open_depth)
+        {
+            byte* native_filename = null;
+            ImGuiNative.igLogToFile(auto_open_depth, native_filename);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LogToFile(int auto_open_depth, ReadOnlySpan<char> filename)
+        {
+            byte* native_filename;
+            int filename_byteCount = 0;
+            if (filename != null)
+            {
+                filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                if (filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_filename = Util.Allocate(filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                    native_filename = native_filename_stackBytes;
+                }
+                int native_filename_offset = Util.GetUtf8(filename, native_filename, filename_byteCount);
+                native_filename[native_filename_offset] = 0;
+            }
+            else { native_filename = null; }
+            ImGuiNative.igLogToFile(auto_open_depth, native_filename);
+            if (filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_filename);
+            }
+        }
+#endif
+        public static void LogToFile(int auto_open_depth, string filename)
+        {
+            byte* native_filename;
+            int filename_byteCount = 0;
+            if (filename != null)
+            {
+                filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                if (filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_filename = Util.Allocate(filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                    native_filename = native_filename_stackBytes;
+                }
+                int native_filename_offset = Util.GetUtf8(filename, native_filename, filename_byteCount);
+                native_filename[native_filename_offset] = 0;
+            }
+            else { native_filename = null; }
+            ImGuiNative.igLogToFile(auto_open_depth, native_filename);
+            if (filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_filename);
+            }
+        }
+        public static void LogToTTY()
+        {
+            int auto_open_depth = -1;
+            ImGuiNative.igLogToTTY(auto_open_depth);
+        }
+        public static void LogToTTY(int auto_open_depth)
+        {
+            ImGuiNative.igLogToTTY(auto_open_depth);
+        }
+        public static IntPtr MemAlloc(uint size)
+        {
+            void* ret = ImGuiNative.igMemAlloc(size);
+            return (IntPtr)ret;
+        }
+        public static void MemFree(IntPtr ptr)
+        {
+            void* native_ptr = (void*)ptr.ToPointer();
+            ImGuiNative.igMemFree(native_ptr);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool MenuItem(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut = null;
+            byte selected = 0;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool MenuItem(string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut = null;
+            byte selected = 0;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool MenuItem(ReadOnlySpan<char> label, ReadOnlySpan<char> shortcut)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte selected = 0;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool MenuItem(string label, string shortcut)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte selected = 0;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool MenuItem(ReadOnlySpan<char> label, ReadOnlySpan<char> shortcut, bool selected)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, native_selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool MenuItem(string label, string shortcut, bool selected)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, native_selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool MenuItem(ReadOnlySpan<char> label, ReadOnlySpan<char> shortcut, bool selected, bool enabled)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, native_selected, native_enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igMenuItem_Bool(native_label, native_shortcut, native_selected, native_enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool MenuItem(ReadOnlySpan<char> label, ReadOnlySpan<char> shortcut, ref bool p_selected)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_BoolPtr(native_label, native_shortcut, native_p_selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
+        }
+#endif
+        public static bool MenuItem(string label, string shortcut, ref bool p_selected)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            byte enabled = 1;
+            byte ret = ImGuiNative.igMenuItem_BoolPtr(native_label, native_shortcut, native_p_selected, enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool MenuItem(ReadOnlySpan<char> label, ReadOnlySpan<char> shortcut, ref bool p_selected, bool enabled)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igMenuItem_BoolPtr(native_label, native_shortcut, native_p_selected, native_enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
+        }
+#endif
+        public static bool MenuItem(string label, string shortcut, ref bool p_selected, bool enabled)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_shortcut;
+            int shortcut_byteCount = 0;
+            if (shortcut != null)
+            {
+                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
+                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
+                    native_shortcut = native_shortcut_stackBytes;
+                }
+                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
+                native_shortcut[native_shortcut_offset] = 0;
+            }
+            else { native_shortcut = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igMenuItem_BoolPtr(native_label, native_shortcut, native_p_selected, native_enabled);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_shortcut);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
+        }
+        public static void NewFrame()
+        {
+            ImGuiNative.igNewFrame();
+        }
+        public static void NewLine()
+        {
+            ImGuiNative.igNewLine();
+        }
+        public static void NextColumn()
+        {
+            ImGuiNative.igNextColumn();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void OpenPopup(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)0;
+            ImGuiNative.igOpenPopup_Str(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#endif
+        public static void OpenPopup(string str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)0;
+            ImGuiNative.igOpenPopup_Str(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void OpenPopup(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igOpenPopup_Str(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#endif
+        public static void OpenPopup(string str_id, ImGuiPopupFlags popup_flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igOpenPopup_Str(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+        public static void OpenPopup(uint id)
+        {
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)0;
+            ImGuiNative.igOpenPopup_ID(id, popup_flags);
+        }
+        public static void OpenPopup(uint id, ImGuiPopupFlags popup_flags)
+        {
+            ImGuiNative.igOpenPopup_ID(id, popup_flags);
+        }
+        public static void OpenPopupOnItemClick()
+        {
+            byte* native_str_id = null;
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            ImGuiNative.igOpenPopupOnItemClick(native_str_id, popup_flags);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void OpenPopupOnItemClick(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            ImGuiNative.igOpenPopupOnItemClick(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#endif
+        public static void OpenPopupOnItemClick(string str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiPopupFlags popup_flags = (ImGuiPopupFlags)1;
+            ImGuiNative.igOpenPopupOnItemClick(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void OpenPopupOnItemClick(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igOpenPopupOnItemClick(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#endif
+        public static void OpenPopupOnItemClick(string str_id, ImGuiPopupFlags popup_flags)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igOpenPopupOnItemClick(native_str_id, popup_flags);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int values_offset = 0;
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int values_offset = 0;
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotHistogram_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int values_offset = 0;
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            int values_offset = 0;
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count, int values_offset)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text = null;
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_min = float.MaxValue;
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            float scale_max = float.MaxValue;
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            Vector2 graph_size = new Vector2();
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+#endif
+        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_overlay_text;
+            int overlay_text_byteCount = 0;
+            if (overlay_text != null)
+            {
+                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
+                    native_overlay_text = native_overlay_text_stackBytes;
+                }
+                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
+                native_overlay_text[native_overlay_text_offset] = 0;
+            }
+            else { native_overlay_text = null; }
+            fixed (float* native_values = &values)
+            {
+                ImGuiNative.igPlotLines_FloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_overlay_text);
+                }
+            }
+        }
+        public static void PopClipRect()
+        {
+            ImGuiNative.igPopClipRect();
+        }
+        public static void PopFont()
+        {
+            ImGuiNative.igPopFont();
+        }
+        public static void PopID()
+        {
+            ImGuiNative.igPopID();
+        }
+        public static void PopItemFlag()
+        {
+            ImGuiNative.igPopItemFlag();
+        }
+        public static void PopItemWidth()
+        {
+            ImGuiNative.igPopItemWidth();
+        }
+        public static void PopStyleColor()
+        {
+            int count = 1;
+            ImGuiNative.igPopStyleColor(count);
+        }
+        public static void PopStyleColor(int count)
+        {
+            ImGuiNative.igPopStyleColor(count);
+        }
+        public static void PopStyleVar()
+        {
+            int count = 1;
+            ImGuiNative.igPopStyleVar(count);
+        }
+        public static void PopStyleVar(int count)
+        {
+            ImGuiNative.igPopStyleVar(count);
+        }
+        public static void PopTextWrapPos()
+        {
+            ImGuiNative.igPopTextWrapPos();
+        }
+        public static void ProgressBar(float fraction)
+        {
+            Vector2 size_arg = new Vector2(-float.MinValue, 0.0f);
+            byte* native_overlay = null;
+            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
+        }
+        public static void ProgressBar(float fraction, Vector2 size_arg)
+        {
+            byte* native_overlay = null;
+            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ProgressBar(float fraction, Vector2 size_arg, ReadOnlySpan<char> overlay)
+        {
+            byte* native_overlay;
+            int overlay_byteCount = 0;
+            if (overlay != null)
+            {
+                overlay_byteCount = Encoding.UTF8.GetByteCount(overlay);
+                if (overlay_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay = Util.Allocate(overlay_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_stackBytes = stackalloc byte[overlay_byteCount + 1];
+                    native_overlay = native_overlay_stackBytes;
+                }
+                int native_overlay_offset = Util.GetUtf8(overlay, native_overlay, overlay_byteCount);
+                native_overlay[native_overlay_offset] = 0;
+            }
+            else { native_overlay = null; }
+            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
+            if (overlay_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_overlay);
+            }
+        }
+#endif
+        public static void ProgressBar(float fraction, Vector2 size_arg, string overlay)
+        {
+            byte* native_overlay;
+            int overlay_byteCount = 0;
+            if (overlay != null)
+            {
+                overlay_byteCount = Encoding.UTF8.GetByteCount(overlay);
+                if (overlay_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_overlay = Util.Allocate(overlay_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_overlay_stackBytes = stackalloc byte[overlay_byteCount + 1];
+                    native_overlay = native_overlay_stackBytes;
+                }
+                int native_overlay_offset = Util.GetUtf8(overlay, native_overlay, overlay_byteCount);
+                native_overlay[native_overlay_offset] = 0;
+            }
+            else { native_overlay = null; }
+            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
+            if (overlay_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_overlay);
+            }
+        }
+        public static void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
+        {
+            byte native_intersect_with_current_clip_rect = intersect_with_current_clip_rect ? (byte)1 : (byte)0;
+            ImGuiNative.igPushClipRect(clip_rect_min, clip_rect_max, native_intersect_with_current_clip_rect);
+        }
+        public static void PushFont(ImFontPtr font)
+        {
+            ImFont* native_font = font.NativePtr;
+            ImGuiNative.igPushFont(native_font);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PushID(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igPushID_Str(native_str_id);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#endif
+        public static void PushID(string str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igPushID_Str(native_str_id);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+        public static void PushID(IntPtr ptr_id)
+        {
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            ImGuiNative.igPushID_Ptr(native_ptr_id);
+        }
+        public static void PushID(int int_id)
+        {
+            ImGuiNative.igPushID_Int(int_id);
+        }
+        public static void PushItemFlag(ImGuiItemFlags option, bool enabled)
+        {
+            byte native_enabled = enabled ? (byte)1 : (byte)0;
+            ImGuiNative.igPushItemFlag(option, native_enabled);
+        }
+        public static void PushItemWidth(float item_width)
+        {
+            ImGuiNative.igPushItemWidth(item_width);
+        }
+        public static void PushStyleColor(ImGuiCol idx, uint col)
+        {
+            ImGuiNative.igPushStyleColor_U32(idx, col);
+        }
+        public static void PushStyleColor(ImGuiCol idx, Vector4 col)
+        {
+            ImGuiNative.igPushStyleColor_Vec4(idx, col);
+        }
+        public static void PushStyleVar(ImGuiStyleVar idx, float val)
+        {
+            ImGuiNative.igPushStyleVar_Float(idx, val);
+        }
+        public static void PushStyleVar(ImGuiStyleVar idx, Vector2 val)
+        {
+            ImGuiNative.igPushStyleVar_Vec2(idx, val);
+        }
+        public static void PushStyleVarX(ImGuiStyleVar idx, float val_x)
+        {
+            ImGuiNative.igPushStyleVarX(idx, val_x);
+        }
+        public static void PushStyleVarY(ImGuiStyleVar idx, float val_y)
+        {
+            ImGuiNative.igPushStyleVarY(idx, val_y);
+        }
+        public static void PushTextWrapPos()
+        {
+            float wrap_local_pos_x = 0.0f;
+            ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
+        }
+        public static void PushTextWrapPos(float wrap_local_pos_x)
+        {
+            ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool RadioButton(ReadOnlySpan<char> label, bool active)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_active = active ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igRadioButton_Bool(native_label, native_active);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool RadioButton(string label, bool active)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_active = active ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igRadioButton_Bool(native_label, native_active);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool RadioButton(ReadOnlySpan<char> label, ref int v, int v_button)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                Util.Free(native_format);
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igRadioButton_IntPtr(native_label, native_v, v_button);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static void Dummy(Vector2 size)
+#endif
+        public static bool RadioButton(string label, ref int v, int v_button)
         {
-            ImGuiNative.igDummy(size);
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igRadioButton_IntPtr(native_label, native_v, v_button);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                return ret != 0;
+            }
         }
-        public static void End()
+        public static void Render()
         {
-            ImGuiNative.igEnd();
+            ImGuiNative.igRender();
         }
-        public static void EndChild()
+        public static void RenderPlatformWindowsDefault()
         {
-            ImGuiNative.igEndChild();
+            void* platform_render_arg = null;
+            void* renderer_render_arg = null;
+            ImGuiNative.igRenderPlatformWindowsDefault(platform_render_arg, renderer_render_arg);
         }
-        public static void EndChildFrame()
+        public static void RenderPlatformWindowsDefault(IntPtr platform_render_arg)
         {
-            ImGuiNative.igEndChildFrame();
+            void* native_platform_render_arg = (void*)platform_render_arg.ToPointer();
+            void* renderer_render_arg = null;
+            ImGuiNative.igRenderPlatformWindowsDefault(native_platform_render_arg, renderer_render_arg);
         }
-        public static void EndCombo()
+        public static void RenderPlatformWindowsDefault(IntPtr platform_render_arg, IntPtr renderer_render_arg)
         {
-            ImGuiNative.igEndCombo();
+            void* native_platform_render_arg = (void*)platform_render_arg.ToPointer();
+            void* native_renderer_render_arg = (void*)renderer_render_arg.ToPointer();
+            ImGuiNative.igRenderPlatformWindowsDefault(native_platform_render_arg, native_renderer_render_arg);
         }
-        public static void EndDragDropSource()
+        public static void ResetMouseDragDelta()
         {
-            ImGuiNative.igEndDragDropSource();
+            ImGuiMouseButton button = (ImGuiMouseButton)0;
+            ImGuiNative.igResetMouseDragDelta(button);
         }
-        public static void EndDragDropTarget()
+        public static void ResetMouseDragDelta(ImGuiMouseButton button)
         {
-            ImGuiNative.igEndDragDropTarget();
+            ImGuiNative.igResetMouseDragDelta(button);
         }
-        public static void EndFrame()
+        public static void SameLine()
         {
-            ImGuiNative.igEndFrame();
+            float offset_from_start_x = 0.0f;
+            float spacing = -1.0f;
+            ImGuiNative.igSameLine(offset_from_start_x, spacing);
         }
-        public static void EndGroup()
+        public static void SameLine(float offset_from_start_x)
         {
-            ImGuiNative.igEndGroup();
+            float spacing = -1.0f;
+            ImGuiNative.igSameLine(offset_from_start_x, spacing);
         }
-        public static void EndMainMenuBar()
+        public static void SameLine(float offset_from_start_x, float spacing)
         {
-            ImGuiNative.igEndMainMenuBar();
+            ImGuiNative.igSameLine(offset_from_start_x, spacing);
         }
-        public static void EndMenu()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SaveIniSettingsToDisk(ReadOnlySpan<char> ini_filename)
         {
-            ImGuiNative.igEndMenu();
+            byte* native_ini_filename;
+            int ini_filename_byteCount = 0;
+            if (ini_filename != null)
+            {
+                ini_filename_byteCount = Encoding.UTF8.GetByteCount(ini_filename);
+                if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_filename = Util.Allocate(ini_filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_filename_stackBytes = stackalloc byte[ini_filename_byteCount + 1];
+                    native_ini_filename = native_ini_filename_stackBytes;
+                }
+                int native_ini_filename_offset = Util.GetUtf8(ini_filename, native_ini_filename, ini_filename_byteCount);
+                native_ini_filename[native_ini_filename_offset] = 0;
+            }
+            else { native_ini_filename = null; }
+            ImGuiNative.igSaveIniSettingsToDisk(native_ini_filename);
+            if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_filename);
+            }
         }
-        public static void EndMenuBar()
+#endif
+        public static void SaveIniSettingsToDisk(string ini_filename)
         {
-            ImGuiNative.igEndMenuBar();
+            byte* native_ini_filename;
+            int ini_filename_byteCount = 0;
+            if (ini_filename != null)
+            {
+                ini_filename_byteCount = Encoding.UTF8.GetByteCount(ini_filename);
+                if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_ini_filename = Util.Allocate(ini_filename_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_ini_filename_stackBytes = stackalloc byte[ini_filename_byteCount + 1];
+                    native_ini_filename = native_ini_filename_stackBytes;
+                }
+                int native_ini_filename_offset = Util.GetUtf8(ini_filename, native_ini_filename, ini_filename_byteCount);
+                native_ini_filename[native_ini_filename_offset] = 0;
+            }
+            else { native_ini_filename = null; }
+            ImGuiNative.igSaveIniSettingsToDisk(native_ini_filename);
+            if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_ini_filename);
+            }
         }
-        public static void EndPopup()
+        public static string SaveIniSettingsToMemory()
         {
-            ImGuiNative.igEndPopup();
+            uint* out_ini_size = null;
+            byte* ret = ImGuiNative.igSaveIniSettingsToMemory(out_ini_size);
+            return Util.StringFromPtr(ret);
         }
-        public static void EndTabBar()
+        public static string SaveIniSettingsToMemory(out uint out_ini_size)
         {
-            ImGuiNative.igEndTabBar();
+            fixed (uint* native_out_ini_size = &out_ini_size)
+            {
+                byte* ret = ImGuiNative.igSaveIniSettingsToMemory(native_out_ini_size);
+                return Util.StringFromPtr(ret);
+            }
         }
-        public static void EndTabItem()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label)
         {
-            ImGuiNative.igEndTabItem();
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte selected = 0;
+            ImGuiSelectableFlags flags = (ImGuiSelectableFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static void EndTooltip()
+#endif
+        public static bool Selectable(string label)
         {
-            ImGuiNative.igEndTooltip();
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte selected = 0;
+            ImGuiSelectableFlags flags = (ImGuiSelectableFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static string GetClipboardText()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label, bool selected)
         {
-            byte* ret = ImGuiNative.igGetClipboardText();
-            return Util.StringFromPtr(ret);
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            ImGuiSelectableFlags flags = (ImGuiSelectableFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, native_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool Selectable(string label, bool selected)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            ImGuiSelectableFlags flags = (ImGuiSelectableFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, native_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static uint GetColorU32(ImGuiCol idx)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label, bool selected, ImGuiSelectableFlags flags)
         {
-            float alpha_mul = 1.0f;
-            uint ret = ImGuiNative.igGetColorU32(idx, alpha_mul);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, native_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static uint GetColorU32(ImGuiCol idx, float alpha_mul)
+#endif
+        public static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags)
         {
-            uint ret = ImGuiNative.igGetColorU32(idx, alpha_mul);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, native_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static uint GetColorU32(Vector4 col)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label, bool selected, ImGuiSelectableFlags flags, Vector2 size)
         {
-            uint ret = ImGuiNative.igGetColorU32Vec4(col);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, native_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static uint GetColorU32(uint col)
+#endif
+        public static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags, Vector2 size)
         {
-            uint ret = ImGuiNative.igGetColorU32U32(col);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.igSelectable_Bool(native_label, native_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static int GetColumnIndex()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label, ref bool p_selected)
         {
-            int ret = ImGuiNative.igGetColumnIndex();
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            ImGuiSelectableFlags flags = (ImGuiSelectableFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_BoolPtr(native_label, native_p_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
         }
-        public static float GetColumnOffset()
+#endif
+        public static bool Selectable(string label, ref bool p_selected)
         {
-            int column_index = -1;
-            float ret = ImGuiNative.igGetColumnOffset(column_index);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            ImGuiSelectableFlags flags = (ImGuiSelectableFlags)0;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_BoolPtr(native_label, native_p_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
         }
-        public static float GetColumnOffset(int column_index)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label, ref bool p_selected, ImGuiSelectableFlags flags)
         {
-            float ret = ImGuiNative.igGetColumnOffset(column_index);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_BoolPtr(native_label, native_p_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
         }
-        public static int GetColumnsCount()
+#endif
+        public static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags)
         {
-            int ret = ImGuiNative.igGetColumnsCount();
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            Vector2 size = new Vector2();
+            byte ret = ImGuiNative.igSelectable_BoolPtr(native_label, native_p_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
         }
-        public static float GetColumnWidth()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool Selectable(ReadOnlySpan<char> label, ref bool p_selected, ImGuiSelectableFlags flags, Vector2 size)
         {
-            int column_index = -1;
-            float ret = ImGuiNative.igGetColumnWidth(column_index);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            byte ret = ImGuiNative.igSelectable_BoolPtr(native_label, native_p_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
         }
-        public static float GetColumnWidth(int column_index)
+#endif
+        public static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags, Vector2 size)
         {
-            float ret = ImGuiNative.igGetColumnWidth(column_index);
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
+            byte* native_p_selected = &native_p_selected_val;
+            byte ret = ImGuiNative.igSelectable_BoolPtr(native_label, native_p_selected, flags, size);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            p_selected = native_p_selected_val != 0;
+            return ret != 0;
         }
-        public static Vector2 GetContentRegionAvail()
+        public static void Separator()
         {
-            Vector2 ret = ImGuiNative.igGetContentRegionAvail();
-            return ret;
+            ImGuiNative.igSeparator();
         }
-        public static float GetContentRegionAvailWidth()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SeparatorText(ReadOnlySpan<char> label)
         {
-            float ret = ImGuiNative.igGetContentRegionAvailWidth();
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiNative.igSeparatorText(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
         }
-        public static Vector2 GetContentRegionMax()
+#endif
+        public static void SeparatorText(string label)
         {
-            Vector2 ret = ImGuiNative.igGetContentRegionMax();
-            return ret;
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiNative.igSeparatorText(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
         }
-        public static IntPtr GetCurrentContext()
+        public static void SetAllocatorFunctions(IntPtr alloc_func, IntPtr free_func)
         {
-            IntPtr ret = ImGuiNative.igGetCurrentContext();
-            return ret;
+            void* user_data = null;
+            ImGuiNative.igSetAllocatorFunctions(alloc_func, free_func, user_data);
         }
-        public static Vector2 GetCursorPos()
+        public static void SetAllocatorFunctions(IntPtr alloc_func, IntPtr free_func, IntPtr user_data)
         {
-            Vector2 ret = ImGuiNative.igGetCursorPos();
-            return ret;
+            void* native_user_data = (void*)user_data.ToPointer();
+            ImGuiNative.igSetAllocatorFunctions(alloc_func, free_func, native_user_data);
         }
-        public static float GetCursorPosX()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetClipboardText(ReadOnlySpan<char> text)
         {
-            float ret = ImGuiNative.igGetCursorPosX();
-            return ret;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.igSetClipboardText(native_text);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
         }
-        public static float GetCursorPosY()
+#endif
+        public static void SetClipboardText(string text)
         {
-            float ret = ImGuiNative.igGetCursorPosY();
-            return ret;
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.igSetClipboardText(native_text);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
         }
-        public static Vector2 GetCursorScreenPos()
+        public static void SetColorEditOptions(ImGuiColorEditFlags flags)
         {
-            Vector2 ret = ImGuiNative.igGetCursorScreenPos();
-            return ret;
+            ImGuiNative.igSetColorEditOptions(flags);
         }
-        public static Vector2 GetCursorStartPos()
+        public static void SetColumnOffset(int column_index, float offset_x)
         {
-            Vector2 ret = ImGuiNative.igGetCursorStartPos();
-            return ret;
+            ImGuiNative.igSetColumnOffset(column_index, offset_x);
         }
-        public static ImGuiPayloadPtr GetDragDropPayload()
+        public static void SetColumnWidth(int column_index, float width)
         {
-            ImGuiPayload* ret = ImGuiNative.igGetDragDropPayload();
-            return new ImGuiPayloadPtr(ret);
+            ImGuiNative.igSetColumnWidth(column_index, width);
         }
-        public static ImDrawDataPtr GetDrawData()
+        public static void SetCurrentContext(IntPtr ctx)
         {
-            ImDrawData* ret = ImGuiNative.igGetDrawData();
-            return new ImDrawDataPtr(ret);
+            ImGuiNative.igSetCurrentContext(ctx);
         }
-        public static IntPtr GetDrawListSharedData()
+        public static void SetCursorPos(Vector2 local_pos)
         {
-            IntPtr ret = ImGuiNative.igGetDrawListSharedData();
-            return ret;
+            ImGuiNative.igSetCursorPos(local_pos);
         }
-        public static ImFontPtr GetFont()
+        public static void SetCursorPosX(float local_x)
         {
-            ImFont* ret = ImGuiNative.igGetFont();
-            return new ImFontPtr(ret);
+            ImGuiNative.igSetCursorPosX(local_x);
         }
-        public static float GetFontSize()
+        public static void SetCursorPosY(float local_y)
         {
-            float ret = ImGuiNative.igGetFontSize();
-            return ret;
+            ImGuiNative.igSetCursorPosY(local_y);
         }
-        public static Vector2 GetFontTexUvWhitePixel()
+        public static void SetCursorScreenPos(Vector2 pos)
         {
-            Vector2 ret = ImGuiNative.igGetFontTexUvWhitePixel();
-            return ret;
+            ImGuiNative.igSetCursorScreenPos(pos);
         }
-        public static int GetFrameCount()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SetDragDropPayload(ReadOnlySpan<char> type, IntPtr data, uint sz)
         {
-            int ret = ImGuiNative.igGetFrameCount();
-            return ret;
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
+            {
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_type = Util.Allocate(type_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
+                }
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
+            }
+            else { native_type = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImGuiCond cond = (ImGuiCond)0;
+            byte ret = ImGuiNative.igSetDragDropPayload(native_type, native_data, sz, cond);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_type);
+            }
+            return ret != 0;
         }
-        public static float GetFrameHeight()
+#endif
+        public static bool SetDragDropPayload(string type, IntPtr data, uint sz)
         {
-            float ret = ImGuiNative.igGetFrameHeight();
-            return ret;
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
+            {
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_type = Util.Allocate(type_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
+                }
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
+            }
+            else { native_type = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImGuiCond cond = (ImGuiCond)0;
+            byte ret = ImGuiNative.igSetDragDropPayload(native_type, native_data, sz, cond);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_type);
+            }
+            return ret != 0;
         }
-        public static float GetFrameHeightWithSpacing()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SetDragDropPayload(ReadOnlySpan<char> type, IntPtr data, uint sz, ImGuiCond cond)
         {
-            float ret = ImGuiNative.igGetFrameHeightWithSpacing();
-            return ret;
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
+            {
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_type = Util.Allocate(type_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
+                }
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
+            }
+            else { native_type = null; }
+            void* native_data = (void*)data.ToPointer();
+            byte ret = ImGuiNative.igSetDragDropPayload(native_type, native_data, sz, cond);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_type);
+            }
+            return ret != 0;
         }
-        public static uint GetID(string str_id)
+#endif
+        public static bool SetDragDropPayload(string type, IntPtr data, uint sz, ImGuiCond cond)
         {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_type = Util.Allocate(type_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
             }
-            else { native_str_id = null; }
-            uint ret = ImGuiNative.igGetIDStr(native_str_id);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_type = null; }
+            void* native_data = (void*)data.ToPointer();
+            byte ret = ImGuiNative.igSetDragDropPayload(native_type, native_data, sz, cond);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_str_id);
+                Util.Free(native_type);
             }
-            return ret;
-        }
-        public static uint GetID(IntPtr ptr_id)
-        {
-            void* native_ptr_id = (void*)ptr_id.ToPointer();
-            uint ret = ImGuiNative.igGetIDPtr(native_ptr_id);
-            return ret;
+            return ret != 0;
         }
-        public static ImGuiIOPtr GetIO()
+        public static void SetItemDefaultFocus()
         {
-            ImGuiIO* ret = ImGuiNative.igGetIO();
-            return new ImGuiIOPtr(ret);
+            ImGuiNative.igSetItemDefaultFocus();
         }
-        public static Vector2 GetItemRectMax()
+        public static void SetItemKeyOwner(ImGuiKey key)
         {
-            Vector2 ret = ImGuiNative.igGetItemRectMax();
-            return ret;
+            ImGuiNative.igSetItemKeyOwner_Nil(key);
         }
-        public static Vector2 GetItemRectMin()
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetItemTooltip(ReadOnlySpan<char> fmt)
         {
-            Vector2 ret = ImGuiNative.igGetItemRectMin();
-            return ret;
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igSetItemTooltip(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
         }
-        public static Vector2 GetItemRectSize()
+#endif
+        public static void SetItemTooltip(string fmt)
         {
-            Vector2 ret = ImGuiNative.igGetItemRectSize();
-            return ret;
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igSetItemTooltip(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
         }
-        public static int GetKeyIndex(ImGuiKey imgui_key)
+        public static void SetKeyboardFocusHere()
         {
-            int ret = ImGuiNative.igGetKeyIndex(imgui_key);
-            return ret;
+            int offset = 0;
+            ImGuiNative.igSetKeyboardFocusHere(offset);
         }
-        public static int GetKeyPressedAmount(int key_index, float repeat_delay, float rate)
+        public static void SetKeyboardFocusHere(int offset)
         {
-            int ret = ImGuiNative.igGetKeyPressedAmount(key_index, repeat_delay, rate);
-            return ret;
+            ImGuiNative.igSetKeyboardFocusHere(offset);
         }
-        public static ImGuiMouseCursor GetMouseCursor()
+        public static void SetMouseCursor(ImGuiMouseCursor cursor_type)
         {
-            ImGuiMouseCursor ret = ImGuiNative.igGetMouseCursor();
-            return ret;
+            ImGuiNative.igSetMouseCursor(cursor_type);
         }
-        public static Vector2 GetMouseDragDelta()
+        public static void SetNavCursorVisible(bool visible)
         {
-            int button = 0;
-            float lock_threshold = -1.0f;
-            Vector2 ret = ImGuiNative.igGetMouseDragDelta(button, lock_threshold);
-            return ret;
+            byte native_visible = visible ? (byte)1 : (byte)0;
+            ImGuiNative.igSetNavCursorVisible(native_visible);
         }
-        public static Vector2 GetMouseDragDelta(int button)
+        public static void SetNextFrameWantCaptureKeyboard(bool want_capture_keyboard)
         {
-            float lock_threshold = -1.0f;
-            Vector2 ret = ImGuiNative.igGetMouseDragDelta(button, lock_threshold);
-            return ret;
+            byte native_want_capture_keyboard = want_capture_keyboard ? (byte)1 : (byte)0;
+            ImGuiNative.igSetNextFrameWantCaptureKeyboard(native_want_capture_keyboard);
         }
-        public static Vector2 GetMouseDragDelta(int button, float lock_threshold)
+        public static void SetNextFrameWantCaptureMouse(bool want_capture_mouse)
         {
-            Vector2 ret = ImGuiNative.igGetMouseDragDelta(button, lock_threshold);
-            return ret;
+            byte native_want_capture_mouse = want_capture_mouse ? (byte)1 : (byte)0;
+            ImGuiNative.igSetNextFrameWantCaptureMouse(native_want_capture_mouse);
         }
-        public static Vector2 GetMousePos()
+        public static void SetNextItemAllowOverlap()
         {
-            Vector2 ret = ImGuiNative.igGetMousePos();
-            return ret;
+            ImGuiNative.igSetNextItemAllowOverlap();
         }
-        public static Vector2 GetMousePosOnOpeningCurrentPopup()
+        public static void SetNextItemOpen(bool is_open)
         {
-            Vector2 ret = ImGuiNative.igGetMousePosOnOpeningCurrentPopup();
-            return ret;
+            byte native_is_open = is_open ? (byte)1 : (byte)0;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetNextItemOpen(native_is_open, cond);
         }
-        public static ImDrawListPtr GetOverlayDrawList()
+        public static void SetNextItemOpen(bool is_open, ImGuiCond cond)
         {
-            ImDrawList* ret = ImGuiNative.igGetOverlayDrawList();
-            return new ImDrawListPtr(ret);
+            byte native_is_open = is_open ? (byte)1 : (byte)0;
+            ImGuiNative.igSetNextItemOpen(native_is_open, cond);
         }
-        public static float GetScrollMaxX()
+        public static void SetNextItemSelectionUserData(long selection_user_data)
         {
-            float ret = ImGuiNative.igGetScrollMaxX();
-            return ret;
+            ImGuiNative.igSetNextItemSelectionUserData(selection_user_data);
         }
-        public static float GetScrollMaxY()
+        public static void SetNextItemShortcut(ImGuiKey key_chord)
         {
-            float ret = ImGuiNative.igGetScrollMaxY();
-            return ret;
+            ImGuiInputFlags flags = (ImGuiInputFlags)0;
+            ImGuiNative.igSetNextItemShortcut(key_chord, flags);
         }
-        public static float GetScrollX()
+        public static void SetNextItemShortcut(ImGuiKey key_chord, ImGuiInputFlags flags)
         {
-            float ret = ImGuiNative.igGetScrollX();
-            return ret;
+            ImGuiNative.igSetNextItemShortcut(key_chord, flags);
         }
-        public static float GetScrollY()
+        public static void SetNextItemStorageID(uint storage_id)
         {
-            float ret = ImGuiNative.igGetScrollY();
-            return ret;
+            ImGuiNative.igSetNextItemStorageID(storage_id);
         }
-        public static ImGuiStoragePtr GetStateStorage()
+        public static void SetNextItemWidth(float item_width)
         {
-            ImGuiStorage* ret = ImGuiNative.igGetStateStorage();
-            return new ImGuiStoragePtr(ret);
+            ImGuiNative.igSetNextItemWidth(item_width);
         }
-        public static ImGuiStylePtr GetStyle()
+        public static void SetNextWindowBgAlpha(float alpha)
         {
-            ImGuiStyle* ret = ImGuiNative.igGetStyle();
-            return new ImGuiStylePtr(ret);
+            ImGuiNative.igSetNextWindowBgAlpha(alpha);
         }
-        public static string GetStyleColorName(ImGuiCol idx)
+        public static void SetNextWindowClass(ImGuiWindowClassPtr window_class)
         {
-            byte* ret = ImGuiNative.igGetStyleColorName(idx);
-            return Util.StringFromPtr(ret);
+            ImGuiWindowClass* native_window_class = window_class.NativePtr;
+            ImGuiNative.igSetNextWindowClass(native_window_class);
         }
-        public static Vector4* GetStyleColorVec4(ImGuiCol idx)
+        public static void SetNextWindowCollapsed(bool collapsed)
         {
-            Vector4* ret = ImGuiNative.igGetStyleColorVec4(idx);
-            return ret;
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetNextWindowCollapsed(native_collapsed, cond);
         }
-        public static float GetTextLineHeight()
+        public static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
         {
-            float ret = ImGuiNative.igGetTextLineHeight();
-            return ret;
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiNative.igSetNextWindowCollapsed(native_collapsed, cond);
         }
-        public static float GetTextLineHeightWithSpacing()
+        public static void SetNextWindowContentSize(Vector2 size)
         {
-            float ret = ImGuiNative.igGetTextLineHeightWithSpacing();
-            return ret;
+            ImGuiNative.igSetNextWindowContentSize(size);
         }
-        public static double GetTime()
+        public static void SetNextWindowDockID(uint dock_id)
         {
-            double ret = ImGuiNative.igGetTime();
-            return ret;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetNextWindowDockID(dock_id, cond);
         }
-        public static float GetTreeNodeToLabelSpacing()
+        public static void SetNextWindowDockID(uint dock_id, ImGuiCond cond)
         {
-            float ret = ImGuiNative.igGetTreeNodeToLabelSpacing();
-            return ret;
+            ImGuiNative.igSetNextWindowDockID(dock_id, cond);
         }
-        public static string GetVersion()
+        public static void SetNextWindowFocus()
         {
-            byte* ret = ImGuiNative.igGetVersion();
-            return Util.StringFromPtr(ret);
+            ImGuiNative.igSetNextWindowFocus();
         }
-        public static Vector2 GetWindowContentRegionMax()
+        public static void SetNextWindowPos(Vector2 pos)
         {
-            Vector2 ret = ImGuiNative.igGetWindowContentRegionMax();
-            return ret;
+            ImGuiCond cond = (ImGuiCond)0;
+            Vector2 pivot = new Vector2();
+            ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
         }
-        public static Vector2 GetWindowContentRegionMin()
+        public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond)
         {
-            Vector2 ret = ImGuiNative.igGetWindowContentRegionMin();
-            return ret;
+            Vector2 pivot = new Vector2();
+            ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
         }
-        public static float GetWindowContentRegionWidth()
+        public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond, Vector2 pivot)
         {
-            float ret = ImGuiNative.igGetWindowContentRegionWidth();
-            return ret;
+            ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
         }
-        public static ImDrawListPtr GetWindowDrawList()
+        public static void SetNextWindowScroll(Vector2 scroll)
         {
-            ImDrawList* ret = ImGuiNative.igGetWindowDrawList();
-            return new ImDrawListPtr(ret);
+            ImGuiNative.igSetNextWindowScroll(scroll);
         }
-        public static float GetWindowHeight()
+        public static void SetNextWindowSize(Vector2 size)
         {
-            float ret = ImGuiNative.igGetWindowHeight();
-            return ret;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetNextWindowSize(size, cond);
         }
-        public static Vector2 GetWindowPos()
+        public static void SetNextWindowSize(Vector2 size, ImGuiCond cond)
         {
-            Vector2 ret = ImGuiNative.igGetWindowPos();
-            return ret;
+            ImGuiNative.igSetNextWindowSize(size, cond);
         }
-        public static Vector2 GetWindowSize()
+        public static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max)
         {
-            Vector2 ret = ImGuiNative.igGetWindowSize();
-            return ret;
+            ImGuiSizeCallback custom_callback = null;
+            void* custom_callback_data = null;
+            ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data);
         }
-        public static float GetWindowWidth()
+        public static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback)
         {
-            float ret = ImGuiNative.igGetWindowWidth();
-            return ret;
+            void* custom_callback_data = null;
+            ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data);
         }
-        public static void Image(IntPtr user_texture_id, Vector2 size)
+        public static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback, IntPtr custom_callback_data)
         {
-            Vector2 uv0 = new Vector2();
-            Vector2 uv1 = new Vector2(1, 1);
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            Vector4 border_col = new Vector4();
-            ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, border_col);
+            void* native_custom_callback_data = (void*)custom_callback_data.ToPointer();
+            ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, native_custom_callback_data);
         }
-        public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0)
+        public static void SetNextWindowViewport(uint viewport_id)
         {
-            Vector2 uv1 = new Vector2(1, 1);
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            Vector4 border_col = new Vector4();
-            ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, border_col);
+            ImGuiNative.igSetNextWindowViewport(viewport_id);
         }
-        public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1)
+        public static void SetScrollFromPosX(float local_x)
         {
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            Vector4 border_col = new Vector4();
-            ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, border_col);
+            float center_x_ratio = 0.5f;
+            ImGuiNative.igSetScrollFromPosX_Float(local_x, center_x_ratio);
         }
-        public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 tint_col)
+        public static void SetScrollFromPosX(float local_x, float center_x_ratio)
         {
-            Vector4 border_col = new Vector4();
-            ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, border_col);
+            ImGuiNative.igSetScrollFromPosX_Float(local_x, center_x_ratio);
         }
-        public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col)
+        public static void SetScrollFromPosY(float local_y)
         {
-            ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, border_col);
+            float center_y_ratio = 0.5f;
+            ImGuiNative.igSetScrollFromPosY_Float(local_y, center_y_ratio);
         }
-        public static bool ImageButton(IntPtr user_texture_id, Vector2 size)
+        public static void SetScrollFromPosY(float local_y, float center_y_ratio)
         {
-            Vector2 uv0 = new Vector2();
-            Vector2 uv1 = new Vector2(1, 1);
-            int frame_padding = -1;
-            Vector4 bg_col = new Vector4();
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            byte ret = ImGuiNative.igImageButton(user_texture_id, size, uv0, uv1, frame_padding, bg_col, tint_col);
-            return ret != 0;
+            ImGuiNative.igSetScrollFromPosY_Float(local_y, center_y_ratio);
         }
-        public static bool ImageButton(IntPtr user_texture_id, Vector2 size, Vector2 uv0)
+        public static void SetScrollHereX()
         {
-            Vector2 uv1 = new Vector2(1, 1);
-            int frame_padding = -1;
-            Vector4 bg_col = new Vector4();
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            byte ret = ImGuiNative.igImageButton(user_texture_id, size, uv0, uv1, frame_padding, bg_col, tint_col);
-            return ret != 0;
+            float center_x_ratio = 0.5f;
+            ImGuiNative.igSetScrollHereX(center_x_ratio);
         }
-        public static bool ImageButton(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1)
+        public static void SetScrollHereX(float center_x_ratio)
         {
-            int frame_padding = -1;
-            Vector4 bg_col = new Vector4();
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            byte ret = ImGuiNative.igImageButton(user_texture_id, size, uv0, uv1, frame_padding, bg_col, tint_col);
-            return ret != 0;
+            ImGuiNative.igSetScrollHereX(center_x_ratio);
         }
-        public static bool ImageButton(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, int frame_padding)
+        public static void SetScrollHereY()
         {
-            Vector4 bg_col = new Vector4();
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            byte ret = ImGuiNative.igImageButton(user_texture_id, size, uv0, uv1, frame_padding, bg_col, tint_col);
-            return ret != 0;
+            float center_y_ratio = 0.5f;
+            ImGuiNative.igSetScrollHereY(center_y_ratio);
         }
-        public static bool ImageButton(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, int frame_padding, Vector4 bg_col)
+        public static void SetScrollHereY(float center_y_ratio)
         {
-            Vector4 tint_col = new Vector4(1, 1, 1, 1);
-            byte ret = ImGuiNative.igImageButton(user_texture_id, size, uv0, uv1, frame_padding, bg_col, tint_col);
-            return ret != 0;
+            ImGuiNative.igSetScrollHereY(center_y_ratio);
         }
-        public static bool ImageButton(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, int frame_padding, Vector4 bg_col, Vector4 tint_col)
+        public static void SetScrollX(float scroll_x)
         {
-            byte ret = ImGuiNative.igImageButton(user_texture_id, size, uv0, uv1, frame_padding, bg_col, tint_col);
-            return ret != 0;
+            ImGuiNative.igSetScrollX_Float(scroll_x);
         }
-        public static void Indent()
-        {
-            float indent_w = 0.0f;
-            ImGuiNative.igIndent(indent_w);
+        public static void SetScrollY(float scroll_y)
+        {
+            ImGuiNative.igSetScrollY_Float(scroll_y);
         }
-        public static void Indent(float indent_w)
+        public static void SetStateStorage(ImGuiStoragePtr storage)
         {
-            ImGuiNative.igIndent(indent_w);
+            ImGuiStorage* native_storage = storage.NativePtr;
+            ImGuiNative.igSetStateStorage(native_storage);
         }
-        public static bool InputDouble(string label, ref double v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetTabItemClosed(ReadOnlySpan<char> tab_or_docked_window_label)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_tab_or_docked_window_label;
+            int tab_or_docked_window_label_byteCount = 0;
+            if (tab_or_docked_window_label != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                tab_or_docked_window_label_byteCount = Encoding.UTF8.GetByteCount(tab_or_docked_window_label);
+                if (tab_or_docked_window_label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_tab_or_docked_window_label = Util.Allocate(tab_or_docked_window_label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_tab_or_docked_window_label_stackBytes = stackalloc byte[tab_or_docked_window_label_byteCount + 1];
+                    native_tab_or_docked_window_label = native_tab_or_docked_window_label_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_tab_or_docked_window_label_offset = Util.GetUtf8(tab_or_docked_window_label, native_tab_or_docked_window_label, tab_or_docked_window_label_byteCount);
+                native_tab_or_docked_window_label[native_tab_or_docked_window_label_offset] = 0;
             }
-            else { native_label = null; }
-            double step = 0.0;
-            double step_fast = 0.0;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_tab_or_docked_window_label = null; }
+            ImGuiNative.igSetTabItemClosed(native_tab_or_docked_window_label);
+            if (tab_or_docked_window_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_tab_or_docked_window_label);
+            }
+        }
+#endif
+        public static void SetTabItemClosed(string tab_or_docked_window_label)
+        {
+            byte* native_tab_or_docked_window_label;
+            int tab_or_docked_window_label_byteCount = 0;
+            if (tab_or_docked_window_label != null)
+            {
+                tab_or_docked_window_label_byteCount = Encoding.UTF8.GetByteCount(tab_or_docked_window_label);
+                if (tab_or_docked_window_label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_tab_or_docked_window_label = Util.Allocate(tab_or_docked_window_label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_tab_or_docked_window_label_stackBytes = stackalloc byte[tab_or_docked_window_label_byteCount + 1];
+                    native_tab_or_docked_window_label = native_tab_or_docked_window_label_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (double* native_v = &v)
+                int native_tab_or_docked_window_label_offset = Util.GetUtf8(tab_or_docked_window_label, native_tab_or_docked_window_label, tab_or_docked_window_label_byteCount);
+                native_tab_or_docked_window_label[native_tab_or_docked_window_label_offset] = 0;
+            }
+            else { native_tab_or_docked_window_label = null; }
+            ImGuiNative.igSetTabItemClosed(native_tab_or_docked_window_label);
+            if (tab_or_docked_window_label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_tab_or_docked_window_label);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetTooltip(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                return ret != 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igSetTooltip(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
         }
-        public static bool InputDouble(string label, ref double v, double step)
+#endif
+        public static void SetTooltip(string fmt)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_label = null; }
-            double step_fast = 0.0;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_fmt = null; }
+            ImGuiNative.igSetTooltip(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+        public static void SetWindowCollapsed(bool collapsed)
+        {
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowCollapsed_Bool(native_collapsed, cond);
+        }
+        public static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
+        {
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiNative.igSetWindowCollapsed_Bool(native_collapsed, cond);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowCollapsed(ReadOnlySpan<char> name, bool collapsed)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (double* native_v = &v)
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowCollapsed_Str(native_name, native_collapsed, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_name);
+            }
+        }
+#endif
+        public static void SetWindowCollapsed(string name, bool collapsed)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                return ret != 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowCollapsed_Str(native_name, native_collapsed, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
             }
         }
-        public static bool InputDouble(string label, ref double v, double step, double step_fast)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowCollapsed(ReadOnlySpan<char> name, bool collapsed, ImGuiCond cond)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.6f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiNative.igSetWindowCollapsed_Str(native_name, native_collapsed, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+        }
+#endif
+        public static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.6f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (double* native_v = &v)
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
+            ImGuiNative.igSetWindowCollapsed_Str(native_name, native_collapsed, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_name);
+            }
+        }
+        public static void SetWindowFocus()
+        {
+            ImGuiNative.igSetWindowFocus_Nil();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowFocus(ReadOnlySpan<char> name)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                return ret != 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImGuiNative.igSetWindowFocus_Str(native_name);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
             }
         }
-        public static bool InputDouble(string label, ref double v, double step, double step_fast, string format)
+#endif
+        public static void SetWindowFocus(string name)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_name = null; }
+            ImGuiNative.igSetWindowFocus_Str(native_name);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_name);
+            }
+        }
+        public static void SetWindowFontScale(float scale)
+        {
+            ImGuiNative.igSetWindowFontScale(scale);
+        }
+        public static void SetWindowPos(Vector2 pos)
+        {
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowPos_Vec2(pos, cond);
+        }
+        public static void SetWindowPos(Vector2 pos, ImGuiCond cond)
+        {
+            ImGuiNative.igSetWindowPos_Vec2(pos, cond);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowPos(ReadOnlySpan<char> name, Vector2 pos)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (double* native_v = &v)
+            else { native_name = null; }
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowPos_Str(native_name, pos, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_name);
             }
         }
-        public static bool InputDouble(string label, ref double v, double step, double step_fast, string format, ImGuiInputTextFlags flags)
+#endif
+        public static void SetWindowPos(string name, Vector2 pos)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_name = null; }
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowPos_Str(native_name, pos, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_name);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowPos(ReadOnlySpan<char> name, Vector2 pos, ImGuiCond cond)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (double* native_v = &v)
+            else { native_name = null; }
+            ImGuiNative.igSetWindowPos_Str(native_name, pos, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputDouble(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_name);
             }
         }
-        public static bool InputFloat(string label, ref float v)
+#endif
+        public static void SetWindowPos(string name, Vector2 pos, ImGuiCond cond)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            float step = 0.0f;
-            float step_fast = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            ImGuiNative.igSetWindowPos_Str(native_name, pos, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+        }
+        public static void SetWindowSize(Vector2 size)
+        {
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowSize_Vec2(size, cond);
+        }
+        public static void SetWindowSize(Vector2 size, ImGuiCond cond)
+        {
+            ImGuiNative.igSetWindowSize_Vec2(size, cond);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowSize(ReadOnlySpan<char> name, Vector2 size)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (float* native_v = &v)
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowSize_Str(native_name, size, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_name);
+            }
+        }
+#endif
+        public static void SetWindowSize(string name, Vector2 size)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                return ret != 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImGuiCond cond = (ImGuiCond)0;
+            ImGuiNative.igSetWindowSize_Str(native_name, size, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
             }
         }
-        public static bool InputFloat(string label, ref float v, float step)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetWindowSize(ReadOnlySpan<char> name, Vector2 size, ImGuiCond cond)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
             }
-            else { native_label = null; }
-            float step_fast = 0.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_name = null; }
+            ImGuiNative.igSetWindowSize_Str(native_name, size, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+        }
+#endif
+        public static void SetWindowSize(string name, Vector2 size, ImGuiCond cond)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_name = Util.Allocate(name_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (float* native_v = &v)
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImGuiNative.igSetWindowSize_Str(native_name, size, cond);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_name);
             }
         }
-        public static bool InputFloat(string label, ref float v, float step, float step_fast)
+        public static bool Shortcut(ImGuiKey key_chord)
+        {
+            ImGuiInputFlags flags = (ImGuiInputFlags)0;
+            byte ret = ImGuiNative.igShortcut_Nil(key_chord, flags);
+            return ret != 0;
+        }
+        public static bool Shortcut(ImGuiKey key_chord, ImGuiInputFlags flags)
+        {
+            byte ret = ImGuiNative.igShortcut_Nil(key_chord, flags);
+            return ret != 0;
+        }
+        public static void ShowAboutWindow()
+        {
+            byte* p_open = null;
+            ImGuiNative.igShowAboutWindow(p_open);
+        }
+        public static void ShowAboutWindow(ref bool p_open)
+        {
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiNative.igShowAboutWindow(native_p_open);
+            p_open = native_p_open_val != 0;
+        }
+        public static void ShowDebugLogWindow()
+        {
+            byte* p_open = null;
+            ImGuiNative.igShowDebugLogWindow(p_open);
+        }
+        public static void ShowDebugLogWindow(ref bool p_open)
+        {
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiNative.igShowDebugLogWindow(native_p_open);
+            p_open = native_p_open_val != 0;
+        }
+        public static void ShowDemoWindow()
+        {
+            byte* p_open = null;
+            ImGuiNative.igShowDemoWindow(p_open);
+        }
+        public static void ShowDemoWindow(ref bool p_open)
+        {
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiNative.igShowDemoWindow(native_p_open);
+            p_open = native_p_open_val != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ShowFontSelector(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6373,36 +22076,14 @@ public static bool InputFloat(string label, ref float v, float step, float step_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (float* native_v = &v)
+            ImGuiNative.igShowFontSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool InputFloat(string label, ref float v, float step, float step_fast, string format)
+#endif
+        public static void ShowFontSelector(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6422,40 +22103,48 @@ public static bool InputFloat(string label, ref float v, float step, float step_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (float* native_v = &v)
+            ImGuiNative.igShowFontSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool InputFloat(string label, ref float v, float step, float step_fast, string format, ImGuiInputTextFlags flags)
+        public static void ShowIDStackToolWindow()
+        {
+            byte* p_open = null;
+            ImGuiNative.igShowIDStackToolWindow(p_open);
+        }
+        public static void ShowIDStackToolWindow(ref bool p_open)
+        {
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiNative.igShowIDStackToolWindow(native_p_open);
+            p_open = native_p_open_val != 0;
+        }
+        public static void ShowMetricsWindow()
+        {
+            byte* p_open = null;
+            ImGuiNative.igShowMetricsWindow(p_open);
+        }
+        public static void ShowMetricsWindow(ref bool p_open)
+        {
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImGuiNative.igShowMetricsWindow(native_p_open);
+            p_open = native_p_open_val != 0;
+        }
+        public static void ShowStyleEditor()
+        {
+            ImGuiStyle* @ref = null;
+            ImGuiNative.igShowStyleEditor(@ref);
+        }
+        public static void ShowStyleEditor(ImGuiStylePtr @ref)
+        {
+            ImGuiStyle* native_ref = @ref.NativePtr;
+            ImGuiNative.igShowStyleEditor(native_ref);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ShowStyleSelector(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6475,39 +22164,15 @@ public static bool InputFloat(string label, ref float v, float step, float step_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (float* native_v = &v)
+            byte ret = ImGuiNative.igShowStyleSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputFloat(native_label, native_v, step, step_fast, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool InputFloat2(string label, ref Vector2 v)
+#endif
+        public static bool ShowStyleSelector(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6527,36 +22192,19 @@ public static bool InputFloat2(string label, ref Vector2 v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (Vector2* native_v = &v)
+            byte ret = ImGuiNative.igShowStyleSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
+        }
+        public static void ShowUserGuide()
+        {
+            ImGuiNative.igShowUserGuide();
         }
-        public static bool InputFloat2(string label, ref Vector2 v, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6576,11 +22224,11 @@ public static bool InputFloat2(string label, ref Vector2 v, string format)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_degrees_min = -360.0f;
+            float v_degrees_max = +360.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -6590,14 +22238,12 @@ public static bool InputFloat2(string label, ref Vector2 v, string format)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (Vector2* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6609,7 +22255,8 @@ public static bool InputFloat2(string label, ref Vector2 v, string format)
                 return ret != 0;
             }
         }
-        public static bool InputFloat2(string label, ref Vector2 v, string format, ImGuiInputTextFlags flags)
+#endif
+        public static bool SliderAngle(string label, ref float v_rad)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6629,11 +22276,11 @@ public static bool InputFloat2(string label, ref Vector2 v, string format, ImGui
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_degrees_min = -360.0f;
+            float v_degrees_max = +360.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -6643,13 +22290,12 @@ public static bool InputFloat2(string label, ref Vector2 v, string format, ImGui
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (Vector2* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat2(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6661,7 +22307,8 @@ public static bool InputFloat2(string label, ref Vector2 v, string format, ImGui
                 return ret != 0;
             }
         }
-        public static bool InputFloat3(string label, ref Vector3 v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6681,9 +22328,10 @@ public static bool InputFloat3(string label, ref Vector3 v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_degrees_max = +360.0f;
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -6693,12 +22341,12 @@ public static bool InputFloat3(string label, ref Vector3 v)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (Vector3* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6710,7 +22358,8 @@ public static bool InputFloat3(string label, ref Vector3 v)
                 return ret != 0;
             }
         }
-        public static bool InputFloat3(string label, ref Vector3 v, string format)
+#endif
+        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6730,11 +22379,10 @@ public static bool InputFloat3(string label, ref Vector3 v, string format)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            float v_degrees_max = +360.0f;
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -6744,14 +22392,12 @@ public static bool InputFloat3(string label, ref Vector3 v, string format)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (Vector3* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6763,7 +22409,8 @@ public static bool InputFloat3(string label, ref Vector3 v, string format)
                 return ret != 0;
             }
         }
-        public static bool InputFloat3(string label, ref Vector3 v, string format, ImGuiInputTextFlags flags)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min, float v_degrees_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6785,9 +22432,7 @@ public static bool InputFloat3(string label, ref Vector3 v, string format, ImGui
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -6797,13 +22442,12 @@ public static bool InputFloat3(string label, ref Vector3 v, string format, ImGui
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (Vector3* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat3(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6815,7 +22459,8 @@ public static bool InputFloat3(string label, ref Vector3 v, string format, ImGui
                 return ret != 0;
             }
         }
-        public static bool InputFloat4(string label, ref Vector4 v)
+#endif
+        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6837,7 +22482,7 @@ public static bool InputFloat4(string label, ref Vector4 v)
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -6847,12 +22492,12 @@ public static bool InputFloat4(string label, ref Vector4 v)
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            ImGuiInputTextFlags flags = 0;
-            fixed (Vector4* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6864,7 +22509,8 @@ public static bool InputFloat4(string label, ref Vector4 v)
                 return ret != 0;
             }
         }
-        public static bool InputFloat4(string label, ref Vector4 v, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min, float v_degrees_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6902,10 +22548,10 @@ public static bool InputFloat4(string label, ref Vector4 v, string format)
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (Vector4* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6917,7 +22563,8 @@ public static bool InputFloat4(string label, ref Vector4 v, string format)
                 return ret != 0;
             }
         }
-        public static bool InputFloat4(string label, ref Vector4 v, string format, ImGuiInputTextFlags flags)
+#endif
+        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6955,9 +22602,10 @@ public static bool InputFloat4(string label, ref Vector4 v, string format, ImGui
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            fixed (Vector4* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputFloat4(native_label, native_v, native_format, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -6969,7 +22617,8 @@ public static bool InputFloat4(string label, ref Vector4 v, string format, ImGui
                 return ret != 0;
             }
         }
-        public static bool InputInt(string label, ref int v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min, float v_degrees_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -6989,52 +22638,40 @@ public static bool InputInt(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int step = 1;
-            int step_fast = 100;
-            ImGuiInputTextFlags flags = 0;
-            fixed (int* native_v = &v)
-            {
-                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
-            }
-        }
-        public static bool InputInt(string label, ref int v, int step)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_label = null; }
-            int step_fast = 100;
-            ImGuiInputTextFlags flags = 0;
-            fixed (int* native_v = &v)
+            else { native_format = null; }
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool InputInt(string label, ref int v, int step, int step_fast)
+#endif
+        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7054,48 +22691,40 @@ public static bool InputInt(string label, ref int v, int step, int step_fast)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (int* native_v = &v)
-            {
-                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
-            }
-        }
-        public static bool InputInt(string label, ref int v, int step, int step_fast, ImGuiInputTextFlags flags)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_label = null; }
-            fixed (int* native_v = &v)
+            else { native_format = null; }
+            fixed (float* native_v_rad = &v_rad)
             {
-                byte ret = ImGuiNative.igInputInt(native_label, native_v, step, step_fast, flags);
+                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool InputInt2(string label, ref int v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat(ReadOnlySpan<char> label, ref float v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7115,18 +22744,37 @@ public static bool InputInt2(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (int* native_v = &v)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igInputInt2(native_label, native_v, flags);
+                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool InputInt2(string label, ref int v, ImGuiInputTextFlags flags)
+#endif
+        public static bool SliderFloat(string label, ref float v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7146,17 +22794,37 @@ public static bool InputInt2(string label, ref int v, ImGuiInputTextFlags flags)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            fixed (int* native_v = &v)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igInputInt2(native_label, native_v, flags);
+                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool InputInt3(string label, ref int v)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat(ReadOnlySpan<char> label, ref float v, float v_min, float v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7176,48 +22844,41 @@ public static bool InputInt3(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (int* native_v = &v)
-            {
-                byte ret = ImGuiNative.igInputInt3(native_label, native_v, flags);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                return ret != 0;
-            }
-        }
-        public static bool InputInt3(string label, ref int v, ImGuiInputTextFlags flags)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_label = null; }
-            fixed (int* native_v = &v)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                byte ret = ImGuiNative.igInputInt3(native_label, native_v, flags);
+                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
                 }
                 return ret != 0;
             }
         }
-        public static bool InputInt4(string label, ref int v)
+#endif
+        public static bool SliderFloat(string label, ref float v, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7237,18 +22898,41 @@ public static bool InputInt4(string label, ref int v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiInputTextFlags flags = 0;
-            fixed (int* native_v = &v)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                byte ret = ImGuiNative.igInputInt4(native_label, native_v, flags);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool InputInt4(string label, ref int v, ImGuiInputTextFlags flags)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat(ReadOnlySpan<char> label, ref float v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7268,17 +22952,40 @@ public static bool InputInt4(string label, ref int v, ImGuiInputTextFlags flags)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            fixed (int* native_v = &v)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                byte ret = ImGuiNative.igInputInt4(native_label, native_v, flags);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v)
+#endif
+        public static bool SliderFloat(string label, ref float v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7298,19 +23005,40 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* step = null;
-            void* step_fast = null;
-            byte* native_format = null;
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_v, step, step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                Util.Free(native_label);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr step)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7330,19 +23058,37 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* step_fast = null;
-            byte* native_format = null;
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_v, native_step, step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr step, IntPtr step_fast)
+#endif
+        public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7362,19 +23108,37 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* native_step_fast = (void*)step_fast.ToPointer();
-            byte* native_format = null;
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_v, native_step, native_step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr step, IntPtr step_fast, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_min, float v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7394,9 +23158,6 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* native_step_fast = (void*)step_fast.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -7415,19 +23176,23 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_v, native_step, native_step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                Util.Free(native_format);
+                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr step, IntPtr step_fast, string format, ImGuiInputTextFlags flags)
+#endif
+        public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7447,9 +23212,6 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* native_step_fast = (void*)step_fast.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -7468,50 +23230,23 @@ public static bool InputScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            byte ret = ImGuiNative.igInputScalar(native_label, data_type, native_v, native_step, native_step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_format);
-            }
-            return ret != 0;
-        }
-        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v, int components)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector2* native_v = &v)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
-            }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* step = null;
-            void* step_fast = null;
-            byte* native_format = null;
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_v, components, step, step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr step)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7531,51 +23266,40 @@ public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* step_fast = null;
-            byte* native_format = null;
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_v, components, native_step, step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            return ret != 0;
-        }
-        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr step, IntPtr step_fast)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* native_step_fast = (void*)step_fast.ToPointer();
-            byte* native_format = null;
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_v, components, native_step, native_step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            fixed (Vector2* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr step, IntPtr step_fast, string format)
+#endif
+        public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7595,9 +23319,6 @@ public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* native_step_fast = (void*)step_fast.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -7616,19 +23337,22 @@ public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            ImGuiInputTextFlags flags = 0;
-            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_v, components, native_step, native_step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            fixed (Vector2* native_v = &v)
             {
-                Util.Free(native_format);
+                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr step, IntPtr step_fast, string format, ImGuiInputTextFlags flags)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7648,14 +23372,9 @@ public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_step = (void*)step.ToPointer();
-            void* native_step_fast = (void*)step_fast.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -7665,283 +23384,75 @@ public static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr v,
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            byte ret = ImGuiNative.igInputScalarN(native_label, data_type, native_v, components, native_step, native_step_fast, native_format, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_format);
-            }
-            return ret != 0;
-        }
-        public static bool InvisibleButton(string str_id, Vector2 size)
-        {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
-            }
-            else { native_str_id = null; }
-            byte ret = ImGuiNative.igInvisibleButton(native_str_id, size);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
-            }
-            return ret != 0;
-        }
-        public static bool IsAnyItemActive()
-        {
-            byte ret = ImGuiNative.igIsAnyItemActive();
-            return ret != 0;
-        }
-        public static bool IsAnyItemFocused()
-        {
-            byte ret = ImGuiNative.igIsAnyItemFocused();
-            return ret != 0;
-        }
-        public static bool IsAnyItemHovered()
-        {
-            byte ret = ImGuiNative.igIsAnyItemHovered();
-            return ret != 0;
-        }
-        public static bool IsAnyMouseDown()
-        {
-            byte ret = ImGuiNative.igIsAnyMouseDown();
-            return ret != 0;
-        }
-        public static bool IsItemActive()
-        {
-            byte ret = ImGuiNative.igIsItemActive();
-            return ret != 0;
-        }
-        public static bool IsItemClicked()
-        {
-            int mouse_button = 0;
-            byte ret = ImGuiNative.igIsItemClicked(mouse_button);
-            return ret != 0;
-        }
-        public static bool IsItemClicked(int mouse_button)
-        {
-            byte ret = ImGuiNative.igIsItemClicked(mouse_button);
-            return ret != 0;
-        }
-        public static bool IsItemDeactivated()
-        {
-            byte ret = ImGuiNative.igIsItemDeactivated();
-            return ret != 0;
-        }
-        public static bool IsItemDeactivatedAfterEdit()
-        {
-            byte ret = ImGuiNative.igIsItemDeactivatedAfterEdit();
-            return ret != 0;
-        }
-        public static bool IsItemEdited()
-        {
-            byte ret = ImGuiNative.igIsItemEdited();
-            return ret != 0;
-        }
-        public static bool IsItemFocused()
-        {
-            byte ret = ImGuiNative.igIsItemFocused();
-            return ret != 0;
-        }
-        public static bool IsItemHovered()
-        {
-            ImGuiHoveredFlags flags = 0;
-            byte ret = ImGuiNative.igIsItemHovered(flags);
-            return ret != 0;
-        }
-        public static bool IsItemHovered(ImGuiHoveredFlags flags)
-        {
-            byte ret = ImGuiNative.igIsItemHovered(flags);
-            return ret != 0;
-        }
-        public static bool IsItemVisible()
-        {
-            byte ret = ImGuiNative.igIsItemVisible();
-            return ret != 0;
-        }
-        public static bool IsKeyDown(int user_key_index)
-        {
-            byte ret = ImGuiNative.igIsKeyDown(user_key_index);
-            return ret != 0;
-        }
-        public static bool IsKeyPressed(int user_key_index)
-        {
-            byte repeat = 1;
-            byte ret = ImGuiNative.igIsKeyPressed(user_key_index, repeat);
-            return ret != 0;
-        }
-        public static bool IsKeyPressed(int user_key_index, bool repeat)
-        {
-            byte native_repeat = repeat ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igIsKeyPressed(user_key_index, native_repeat);
-            return ret != 0;
-        }
-        public static bool IsKeyReleased(int user_key_index)
-        {
-            byte ret = ImGuiNative.igIsKeyReleased(user_key_index);
-            return ret != 0;
-        }
-        public static bool IsMouseClicked(int button)
-        {
-            byte repeat = 0;
-            byte ret = ImGuiNative.igIsMouseClicked(button, repeat);
-            return ret != 0;
-        }
-        public static bool IsMouseClicked(int button, bool repeat)
-        {
-            byte native_repeat = repeat ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igIsMouseClicked(button, native_repeat);
-            return ret != 0;
-        }
-        public static bool IsMouseDoubleClicked(int button)
-        {
-            byte ret = ImGuiNative.igIsMouseDoubleClicked(button);
-            return ret != 0;
-        }
-        public static bool IsMouseDown(int button)
-        {
-            byte ret = ImGuiNative.igIsMouseDown(button);
-            return ret != 0;
-        }
-        public static bool IsMouseDragging()
-        {
-            int button = 0;
-            float lock_threshold = -1.0f;
-            byte ret = ImGuiNative.igIsMouseDragging(button, lock_threshold);
-            return ret != 0;
-        }
-        public static bool IsMouseDragging(int button)
-        {
-            float lock_threshold = -1.0f;
-            byte ret = ImGuiNative.igIsMouseDragging(button, lock_threshold);
-            return ret != 0;
-        }
-        public static bool IsMouseDragging(int button, float lock_threshold)
-        {
-            byte ret = ImGuiNative.igIsMouseDragging(button, lock_threshold);
-            return ret != 0;
-        }
-        public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max)
-        {
-            byte clip = 1;
-            byte ret = ImGuiNative.igIsMouseHoveringRect(r_min, r_max, clip);
-            return ret != 0;
-        }
-        public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max, bool clip)
-        {
-            byte native_clip = clip ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igIsMouseHoveringRect(r_min, r_max, native_clip);
-            return ret != 0;
-        }
-        public static bool IsMousePosValid()
-        {
-            Vector2* mouse_pos = null;
-            byte ret = ImGuiNative.igIsMousePosValid(mouse_pos);
-            return ret != 0;
-        }
-        public static bool IsMousePosValid(ref Vector2 mouse_pos)
-        {
-            fixed (Vector2* native_mouse_pos = &mouse_pos)
-            {
-                byte ret = ImGuiNative.igIsMousePosValid(native_mouse_pos);
                 return ret != 0;
             }
         }
-        public static bool IsMouseReleased(int button)
-        {
-            byte ret = ImGuiNative.igIsMouseReleased(button);
-            return ret != 0;
-        }
-        public static bool IsPopupOpen(string str_id)
+#endif
+        public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max)
         {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
-            }
-            else { native_str_id = null; }
-            byte ret = ImGuiNative.igIsPopupOpen(native_str_id);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
-        }
-        public static bool IsRectVisible(Vector2 size)
-        {
-            byte ret = ImGuiNative.igIsRectVisible(size);
-            return ret != 0;
-        }
-        public static bool IsRectVisible(Vector2 rect_min, Vector2 rect_max)
-        {
-            byte ret = ImGuiNative.igIsRectVisibleVec2(rect_min, rect_max);
-            return ret != 0;
-        }
-        public static bool IsWindowAppearing()
-        {
-            byte ret = ImGuiNative.igIsWindowAppearing();
-            return ret != 0;
-        }
-        public static bool IsWindowCollapsed()
-        {
-            byte ret = ImGuiNative.igIsWindowCollapsed();
-            return ret != 0;
-        }
-        public static bool IsWindowFocused()
-        {
-            ImGuiFocusedFlags flags = 0;
-            byte ret = ImGuiNative.igIsWindowFocused(flags);
-            return ret != 0;
-        }
-        public static bool IsWindowFocused(ImGuiFocusedFlags flags)
-        {
-            byte ret = ImGuiNative.igIsWindowFocused(flags);
-            return ret != 0;
-        }
-        public static bool IsWindowHovered()
-        {
-            ImGuiHoveredFlags flags = 0;
-            byte ret = ImGuiNative.igIsWindowHovered(flags);
-            return ret != 0;
-        }
-        public static bool IsWindowHovered(ImGuiHoveredFlags flags)
-        {
-            byte ret = ImGuiNative.igIsWindowHovered(flags);
-            return ret != 0;
         }
-        public static void LabelText(string label, string fmt)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_min, float v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -7961,35 +23472,41 @@ public static void LabelText(string label, string fmt)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            ImGuiNative.igLabelText(native_label, native_fmt);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
             {
-                Util.Free(native_fmt);
+                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static bool ListBox(string label, ref int current_item, string[] items, int items_count)
+#endif
+        public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8009,45 +23526,41 @@ public static bool ListBox(string label, ref int current_item, string[] items, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int* items_byteCounts = stackalloc int[items.Length];
-            int items_byteCount = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                string s = items[i];
-                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
-                items_byteCount += items_byteCounts[i] + 1;
-            }
-            byte* native_items_data = stackalloc byte[items_byteCount];
-            int offset = 0;
-            for (int i = 0; i < items.Length; i++)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                string s = items[i];
-                fixed (char* sPtr = s)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_items_data + offset, items_byteCounts[i]);
-                    native_items_data[offset] = 0;
-                    offset += 1;
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            byte** native_items = stackalloc byte*[items.Length];
-            offset = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                native_items[i] = &native_items_data[offset];
-                offset += items_byteCounts[i] + 1;
-            }
-            int height_in_items = -1;
-            fixed (int* native_current_item = &current_item)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector3* native_v = &v)
             {
-                byte ret = ImGuiNative.igListBoxStr_arr(native_label, native_current_item, native_items, items_count, height_in_items);
+                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static bool ListBox(string label, ref int current_item, string[] items, int items_count, int height_in_items)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8067,48 +23580,40 @@ public static bool ListBox(string label, ref int current_item, string[] items, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int* items_byteCounts = stackalloc int[items.Length];
-            int items_byteCount = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                string s = items[i];
-                items_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
-                items_byteCount += items_byteCounts[i] + 1;
-            }
-            byte* native_items_data = stackalloc byte[items_byteCount];
-            int offset = 0;
-            for (int i = 0; i < items.Length; i++)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                string s = items[i];
-                fixed (char* sPtr = s)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    offset += Encoding.UTF8.GetBytes(sPtr, s.Length, native_items_data + offset, items_byteCounts[i]);
-                    native_items_data[offset] = 0;
-                    offset += 1;
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            byte** native_items = stackalloc byte*[items.Length];
-            offset = 0;
-            for (int i = 0; i < items.Length; i++)
-            {
-                native_items[i] = &native_items_data[offset];
-                offset += items_byteCounts[i] + 1;
-            }
-            fixed (int* native_current_item = &current_item)
+            else { native_format = null; }
+            fixed (Vector3* native_v = &v)
             {
-                byte ret = ImGuiNative.igListBoxStr_arr(native_label, native_current_item, native_items, items_count, height_in_items);
+                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static void ListBoxFooter()
-        {
-            ImGuiNative.igListBoxFooter();
-        }
-        public static bool ListBoxHeader(string label)
+#endif
+        public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8128,42 +23633,40 @@ public static bool ListBoxHeader(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igListBoxHeaderVec2(native_label, size);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            return ret != 0;
-        }
-        public static bool ListBoxHeader(string label, Vector2 size)
-        {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_label = null; }
-            byte ret = ImGuiNative.igListBoxHeaderVec2(native_label, size);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            fixed (Vector3* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool ListBoxHeader(string label, int items_count)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8183,15 +23686,37 @@ public static bool ListBoxHeader(string label, int items_count)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int height_in_items = -1;
-            byte ret = ImGuiNative.igListBoxHeaderInt(native_label, items_count, height_in_items);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
             {
-                Util.Free(native_label);
+                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool ListBoxHeader(string label, int items_count, int height_in_items)
+#endif
+        public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8211,192 +23736,91 @@ public static bool ListBoxHeader(string label, int items_count, int height_in_it
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte ret = ImGuiNative.igListBoxHeaderInt(native_label, items_count, height_in_items);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            return ret != 0;
-        }
-        public static void LoadIniSettingsFromDisk(string ini_filename)
-        {
-            byte* native_ini_filename;
-            int ini_filename_byteCount = 0;
-            if (ini_filename != null)
-            {
-                ini_filename_byteCount = Encoding.UTF8.GetByteCount(ini_filename);
-                if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_ini_filename = Util.Allocate(ini_filename_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_ini_filename_stackBytes = stackalloc byte[ini_filename_byteCount + 1];
-                    native_ini_filename = native_ini_filename_stackBytes;
-                }
-                int native_ini_filename_offset = Util.GetUtf8(ini_filename, native_ini_filename, ini_filename_byteCount);
-                native_ini_filename[native_ini_filename_offset] = 0;
-            }
-            else { native_ini_filename = null; }
-            ImGuiNative.igLoadIniSettingsFromDisk(native_ini_filename);
-            if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_ini_filename);
-            }
-        }
-        public static void LoadIniSettingsFromMemory(string ini_data)
-        {
-            byte* native_ini_data;
-            int ini_data_byteCount = 0;
-            if (ini_data != null)
-            {
-                ini_data_byteCount = Encoding.UTF8.GetByteCount(ini_data);
-                if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_ini_data = Util.Allocate(ini_data_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_ini_data_stackBytes = stackalloc byte[ini_data_byteCount + 1];
-                    native_ini_data = native_ini_data_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_ini_data_offset = Util.GetUtf8(ini_data, native_ini_data, ini_data_byteCount);
-                native_ini_data[native_ini_data_offset] = 0;
-            }
-            else { native_ini_data = null; }
-            uint ini_size = 0;
-            ImGuiNative.igLoadIniSettingsFromMemory(native_ini_data, ini_size);
-            if (ini_data_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_ini_data);
-            }
-        }
-        public static void LoadIniSettingsFromMemory(string ini_data, uint ini_size)
-        {
-            byte* native_ini_data;
-            int ini_data_byteCount = 0;
-            if (ini_data != null)
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
             {
-                ini_data_byteCount = Encoding.UTF8.GetByteCount(ini_data);
-                if (ini_data_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_ini_data = Util.Allocate(ini_data_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_ini_data_stackBytes = stackalloc byte[ini_data_byteCount + 1];
-                    native_ini_data = native_ini_data_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_ini_data_offset = Util.GetUtf8(ini_data, native_ini_data, ini_data_byteCount);
-                native_ini_data[native_ini_data_offset] = 0;
-            }
-            else { native_ini_data = null; }
-            ImGuiNative.igLoadIniSettingsFromMemory(native_ini_data, ini_size);
-            if (ini_data_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_ini_data);
+                return ret != 0;
             }
         }
-        public static void LogButtons()
-        {
-            ImGuiNative.igLogButtons();
-        }
-        public static void LogFinish()
-        {
-            ImGuiNative.igLogFinish();
-        }
-        public static void LogText(string fmt)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_min, float v_max, ReadOnlySpan<char> format)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            ImGuiNative.igLogText(native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_fmt);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-        }
-        public static void LogToClipboard()
-        {
-            int max_depth = -1;
-            ImGuiNative.igLogToClipboard(max_depth);
-        }
-        public static void LogToClipboard(int max_depth)
-        {
-            ImGuiNative.igLogToClipboard(max_depth);
-        }
-        public static void LogToFile()
-        {
-            int max_depth = -1;
-            byte* native_filename = null;
-            ImGuiNative.igLogToFile(max_depth, native_filename);
-        }
-        public static void LogToFile(int max_depth)
-        {
-            byte* native_filename = null;
-            ImGuiNative.igLogToFile(max_depth, native_filename);
-        }
-        public static void LogToFile(int max_depth, string filename)
-        {
-            byte* native_filename;
-            int filename_byteCount = 0;
-            if (filename != null)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                filename_byteCount = Encoding.UTF8.GetByteCount(filename);
-                if (filename_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_filename = Util.Allocate(filename_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
-                    native_filename = native_filename_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_filename_offset = Util.GetUtf8(filename, native_filename, filename_byteCount);
-                native_filename[native_filename_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_filename = null; }
-            ImGuiNative.igLogToFile(max_depth, native_filename);
-            if (filename_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
             {
-                Util.Free(native_filename);
+                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void LogToTTY()
-        {
-            int max_depth = -1;
-            ImGuiNative.igLogToTTY(max_depth);
-        }
-        public static void LogToTTY(int max_depth)
-        {
-            ImGuiNative.igLogToTTY(max_depth);
-        }
-        public static IntPtr MemAlloc(uint size)
-        {
-            void* ret = ImGuiNative.igMemAlloc(size);
-            return (IntPtr)ret;
-        }
-        public static void MemFree(IntPtr ptr)
-        {
-            void* native_ptr = (void*)ptr.ToPointer();
-            ImGuiNative.igMemFree(native_ptr);
-        }
-        public static bool MenuItem(string label)
+#endif
+        public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8416,17 +23840,41 @@ public static bool MenuItem(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_shortcut = null;
-            byte selected = 0;
-            byte enabled = 1;
-            byte ret = ImGuiNative.igMenuItemBool(native_label, native_shortcut, selected, enabled);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                Util.Free(native_label);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (Vector4* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool MenuItem(string label, string shortcut)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8446,38 +23894,40 @@ public static bool MenuItem(string label, string shortcut)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_shortcut;
-            int shortcut_byteCount = 0;
-            if (shortcut != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
-                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
-                    native_shortcut = native_shortcut_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
-                native_shortcut[native_shortcut_offset] = 0;
-            }
-            else { native_shortcut = null; }
-            byte selected = 0;
-            byte enabled = 1;
-            byte ret = ImGuiNative.igMenuItemBool(native_label, native_shortcut, selected, enabled);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            fixed (Vector4* native_v = &v)
             {
-                Util.Free(native_shortcut);
+                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool MenuItem(string label, string shortcut, bool selected)
+#endif
+        public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8497,38 +23947,40 @@ public static bool MenuItem(string label, string shortcut, bool selected)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_shortcut;
-            int shortcut_byteCount = 0;
-            if (shortcut != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
-                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
-                    native_shortcut = native_shortcut_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
-                native_shortcut[native_shortcut_offset] = 0;
-            }
-            else { native_shortcut = null; }
-            byte native_selected = selected ? (byte)1 : (byte)0;
-            byte enabled = 1;
-            byte ret = ImGuiNative.igMenuItemBool(native_label, native_shortcut, native_selected, enabled);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            fixed (Vector4* native_v = &v)
             {
-                Util.Free(native_shortcut);
+                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8548,38 +24000,37 @@ public static bool MenuItem(string label, string shortcut, bool selected, bool e
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_shortcut;
-            int shortcut_byteCount = 0;
-            if (shortcut != null)
-            {
-                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
-                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
-                    native_shortcut = native_shortcut_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
-                native_shortcut[native_shortcut_offset] = 0;
-            }
-            else { native_shortcut = null; }
-            byte native_selected = selected ? (byte)1 : (byte)0;
-            byte native_enabled = enabled ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igMenuItemBool(native_label, native_shortcut, native_selected, native_enabled);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                Util.Free(native_shortcut);
+                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool MenuItem(string label, string shortcut, ref bool p_selected)
+#endif
+        public static bool SliderInt(string label, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8599,40 +24050,37 @@ public static bool MenuItem(string label, string shortcut, ref bool p_selected)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_shortcut;
-            int shortcut_byteCount = 0;
-            if (shortcut != null)
-            {
-                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
-                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
-                    native_shortcut = native_shortcut_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
-                native_shortcut[native_shortcut_offset] = 0;
-            }
-            else { native_shortcut = null; }
-            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
-            byte* native_p_selected = &native_p_selected_val;
-            byte enabled = 1;
-            byte ret = ImGuiNative.igMenuItemBoolPtr(native_label, native_shortcut, native_p_selected, enabled);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                Util.Free(native_shortcut);
+                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            p_selected = native_p_selected_val != 0;
-            return ret != 0;
         }
-        public static bool MenuItem(string label, string shortcut, ref bool p_selected, bool enabled)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8652,175 +24100,148 @@ public static bool MenuItem(string label, string shortcut, ref bool p_selected,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_shortcut;
-            int shortcut_byteCount = 0;
-            if (shortcut != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                shortcut_byteCount = Encoding.UTF8.GetByteCount(shortcut);
-                if (shortcut_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_shortcut = Util.Allocate(shortcut_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_shortcut_stackBytes = stackalloc byte[shortcut_byteCount + 1];
-                    native_shortcut = native_shortcut_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_shortcut_offset = Util.GetUtf8(shortcut, native_shortcut, shortcut_byteCount);
-                native_shortcut[native_shortcut_offset] = 0;
-            }
-            else { native_shortcut = null; }
-            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
-            byte* native_p_selected = &native_p_selected_val;
-            byte native_enabled = enabled ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igMenuItemBoolPtr(native_label, native_shortcut, native_p_selected, native_enabled);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            if (shortcut_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_shortcut);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            p_selected = native_p_selected_val != 0;
-            return ret != 0;
-        }
-        public static void NewFrame()
-        {
-            ImGuiNative.igNewFrame();
-        }
-        public static void NewLine()
-        {
-            ImGuiNative.igNewLine();
-        }
-        public static void NextColumn()
-        {
-            ImGuiNative.igNextColumn();
-        }
-        public static void OpenPopup(string str_id)
-        {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
-            }
-            else { native_str_id = null; }
-            ImGuiNative.igOpenPopup(native_str_id);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
+                return ret != 0;
             }
         }
-        public static bool OpenPopupOnItemClick()
-        {
-            byte* native_str_id = null;
-            int mouse_button = 1;
-            byte ret = ImGuiNative.igOpenPopupOnItemClick(native_str_id, mouse_button);
-            return ret != 0;
-        }
-        public static bool OpenPopupOnItemClick(string str_id)
+#endif
+        public static bool SliderInt(string label, ref int v, int v_min, int v_max, string format)
         {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
-            }
-            else { native_str_id = null; }
-            int mouse_button = 1;
-            byte ret = ImGuiNative.igOpenPopupOnItemClick(native_str_id, mouse_button);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            return ret != 0;
-        }
-        public static bool OpenPopupOnItemClick(string str_id, int mouse_button)
-        {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_str_id = null; }
-            byte ret = ImGuiNative.igOpenPopupOnItemClick(native_str_id, mouse_button);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                Util.Free(native_str_id);
+                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static void PlotHistogram(string label, ref float values, int values_count)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
             if (label != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_label = null; }
-            int values_offset = 0;
-            byte* native_overlay_text = null;
-            float scale_min = float.MaxValue;
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset)
+#endif
+        public static bool SliderInt(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8840,21 +24261,40 @@ public static void PlotHistogram(string label, ref float values, int values_coun
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text = null;
-            float scale_min = float.MaxValue;
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt2(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8874,42 +24314,37 @@ public static void PlotHistogram(string label, ref float values, int values_coun
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
-            {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
-            }
-            else { native_overlay_text = null; }
-            float scale_min = float.MaxValue;
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
+#endif
+        public static bool SliderInt2(string label, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8929,41 +24364,37 @@ public static void PlotHistogram(string label, ref float values, int values_coun
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
-            {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
-            }
-            else { native_overlay_text = null; }
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt2(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -8983,40 +24414,41 @@ public static void PlotHistogram(string label, ref float values, int values_coun
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size)
+#endif
+        public static bool SliderInt2(string label, ref int v, int v_min, int v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9036,39 +24468,41 @@ public static void PlotHistogram(string label, ref float values, int values_coun
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt2(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9088,38 +24522,40 @@ public static void PlotHistogram(string label, ref float values, int values_coun
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotHistogramFloatPtr(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count)
+#endif
+        public static bool SliderInt2(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9139,22 +24575,40 @@ public static void PlotLines(string label, ref float values, int values_count)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            int values_offset = 0;
-            byte* native_overlay_text = null;
-            float scale_min = float.MaxValue;
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count, int values_offset)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt3(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9174,21 +24628,37 @@ public static void PlotLines(string label, ref float values, int values_count, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text = null;
-            float scale_min = float.MaxValue;
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text)
+#endif
+        public static bool SliderInt3(string label, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9208,42 +24678,37 @@ public static void PlotLines(string label, ref float values, int values_count, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
-            {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
-            }
-            else { native_overlay_text = null; }
-            float scale_min = float.MaxValue;
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt3(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9263,41 +24728,41 @@ public static void PlotLines(string label, ref float values, int values_count, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            float scale_max = float.MaxValue;
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max)
+#endif
+        public static bool SliderInt3(string label, ref int v, int v_min, int v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9317,40 +24782,41 @@ public static void PlotLines(string label, ref float values, int values_count, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            Vector2 graph_size = new Vector2();
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt3(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9370,39 +24836,40 @@ public static void PlotLines(string label, ref float values, int values_count, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            int stride = sizeof(float);
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
+#endif
+        public static bool SliderInt3(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9422,205 +24889,140 @@ public static void PlotLines(string label, ref float values, int values_count, i
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_overlay_text;
-            int overlay_text_byteCount = 0;
-            if (overlay_text != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                overlay_text_byteCount = Encoding.UTF8.GetByteCount(overlay_text);
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay_text = Util.Allocate(overlay_text_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_text_stackBytes = stackalloc byte[overlay_text_byteCount + 1];
-                    native_overlay_text = native_overlay_text_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_text_offset = Util.GetUtf8(overlay_text, native_overlay_text, overlay_text_byteCount);
-                native_overlay_text[native_overlay_text_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_overlay_text = null; }
-            fixed (float* native_values = &values)
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                ImGuiNative.igPlotLines(native_label, native_values, values_count, values_offset, native_overlay_text, scale_min, scale_max, graph_size, stride);
+                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
-                if (overlay_text_byteCount > Util.StackAllocationSizeLimit)
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_overlay_text);
+                    Util.Free(native_format);
                 }
+                return ret != 0;
             }
         }
-        public static void PopAllowKeyboardFocus()
-        {
-            ImGuiNative.igPopAllowKeyboardFocus();
-        }
-        public static void PopButtonRepeat()
-        {
-            ImGuiNative.igPopButtonRepeat();
-        }
-        public static void PopClipRect()
-        {
-            ImGuiNative.igPopClipRect();
-        }
-        public static void PopFont()
-        {
-            ImGuiNative.igPopFont();
-        }
-        public static void PopID()
-        {
-            ImGuiNative.igPopID();
-        }
-        public static void PopItemWidth()
-        {
-            ImGuiNative.igPopItemWidth();
-        }
-        public static void PopStyleColor()
-        {
-            int count = 1;
-            ImGuiNative.igPopStyleColor(count);
-        }
-        public static void PopStyleColor(int count)
-        {
-            ImGuiNative.igPopStyleColor(count);
-        }
-        public static void PopStyleVar()
-        {
-            int count = 1;
-            ImGuiNative.igPopStyleVar(count);
-        }
-        public static void PopStyleVar(int count)
-        {
-            ImGuiNative.igPopStyleVar(count);
-        }
-        public static void PopTextWrapPos()
-        {
-            ImGuiNative.igPopTextWrapPos();
-        }
-        public static void ProgressBar(float fraction)
-        {
-            Vector2 size_arg = new Vector2(-1, 0);
-            byte* native_overlay = null;
-            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
-        }
-        public static void ProgressBar(float fraction, Vector2 size_arg)
-        {
-            byte* native_overlay = null;
-            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
-        }
-        public static void ProgressBar(float fraction, Vector2 size_arg, string overlay)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt4(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
         {
-            byte* native_overlay;
-            int overlay_byteCount = 0;
-            if (overlay != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                overlay_byteCount = Encoding.UTF8.GetByteCount(overlay);
-                if (overlay_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_overlay = Util.Allocate(overlay_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_overlay_stackBytes = stackalloc byte[overlay_byteCount + 1];
-                    native_overlay = native_overlay_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_overlay_offset = Util.GetUtf8(overlay, native_overlay, overlay_byteCount);
-                native_overlay[native_overlay_offset] = 0;
-            }
-            else { native_overlay = null; }
-            ImGuiNative.igProgressBar(fraction, size_arg, native_overlay);
-            if (overlay_byteCount > Util.StackAllocationSizeLimit)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                Util.Free(native_overlay);
+                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void PushAllowKeyboardFocus(bool allow_keyboard_focus)
-        {
-            byte native_allow_keyboard_focus = allow_keyboard_focus ? (byte)1 : (byte)0;
-            ImGuiNative.igPushAllowKeyboardFocus(native_allow_keyboard_focus);
-        }
-        public static void PushButtonRepeat(bool repeat)
-        {
-            byte native_repeat = repeat ? (byte)1 : (byte)0;
-            ImGuiNative.igPushButtonRepeat(native_repeat);
-        }
-        public static void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
-        {
-            byte native_intersect_with_current_clip_rect = intersect_with_current_clip_rect ? (byte)1 : (byte)0;
-            ImGuiNative.igPushClipRect(clip_rect_min, clip_rect_max, native_intersect_with_current_clip_rect);
-        }
-        public static void PushFont(ImFontPtr font)
-        {
-            ImFont* native_font = font.NativePtr;
-            ImGuiNative.igPushFont(native_font);
-        }
-        public static void PushID(string str_id)
+#endif
+        public static bool SliderInt4(string label, ref int v, int v_min, int v_max)
         {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_str_id = null; }
-            ImGuiNative.igPushIDStr(native_str_id);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                Util.Free(native_str_id);
+                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static void PushID(IntPtr ptr_id)
-        {
-            void* native_ptr_id = (void*)ptr_id.ToPointer();
-            ImGuiNative.igPushIDPtr(native_ptr_id);
-        }
-        public static void PushID(int int_id)
-        {
-            ImGuiNative.igPushIDInt(int_id);
-        }
-        public static void PushItemWidth(float item_width)
-        {
-            ImGuiNative.igPushItemWidth(item_width);
-        }
-        public static void PushStyleColor(ImGuiCol idx, uint col)
-        {
-            ImGuiNative.igPushStyleColorU32(idx, col);
-        }
-        public static void PushStyleColor(ImGuiCol idx, Vector4 col)
-        {
-            ImGuiNative.igPushStyleColor(idx, col);
-        }
-        public static void PushStyleVar(ImGuiStyleVar idx, float val)
-        {
-            ImGuiNative.igPushStyleVarFloat(idx, val);
-        }
-        public static void PushStyleVar(ImGuiStyleVar idx, Vector2 val)
-        {
-            ImGuiNative.igPushStyleVarVec2(idx, val);
-        }
-        public static void PushTextWrapPos()
-        {
-            float wrap_local_pos_x = 0.0f;
-            ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
-        }
-        public static void PushTextWrapPos(float wrap_local_pos_x)
-        {
-            ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
-        }
-        public static bool RadioButton(string label, bool active)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt4(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9640,15 +25042,41 @@ public static bool RadioButton(string label, bool active)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_active = active ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igRadioButtonBool(native_label, native_active);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                Util.Free(native_label);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool RadioButton(string label, ref int v, int v_button)
+#endif
+        public static bool SliderInt4(string label, ref int v, int v_min, int v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9668,85 +25096,94 @@ public static bool RadioButton(string label, ref int v, int v_button)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
             fixed (int* native_v = &v)
             {
-                byte ret = ImGuiNative.igRadioButtonIntPtr(native_label, native_v, v_button);
+                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
                 }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
                 return ret != 0;
             }
         }
-        public static void Render()
-        {
-            ImGuiNative.igRender();
-        }
-        public static void ResetMouseDragDelta()
-        {
-            int button = 0;
-            ImGuiNative.igResetMouseDragDelta(button);
-        }
-        public static void ResetMouseDragDelta(int button)
-        {
-            ImGuiNative.igResetMouseDragDelta(button);
-        }
-        public static void SameLine()
-        {
-            float local_pos_x = 0.0f;
-            float spacing_w = -1.0f;
-            ImGuiNative.igSameLine(local_pos_x, spacing_w);
-        }
-        public static void SameLine(float local_pos_x)
-        {
-            float spacing_w = -1.0f;
-            ImGuiNative.igSameLine(local_pos_x, spacing_w);
-        }
-        public static void SameLine(float local_pos_x, float spacing_w)
-        {
-            ImGuiNative.igSameLine(local_pos_x, spacing_w);
-        }
-        public static void SaveIniSettingsToDisk(string ini_filename)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderInt4(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
-            byte* native_ini_filename;
-            int ini_filename_byteCount = 0;
-            if (ini_filename != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                ini_filename_byteCount = Encoding.UTF8.GetByteCount(ini_filename);
-                if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_ini_filename = Util.Allocate(ini_filename_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_ini_filename_stackBytes = stackalloc byte[ini_filename_byteCount + 1];
-                    native_ini_filename = native_ini_filename_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_ini_filename_offset = Util.GetUtf8(ini_filename, native_ini_filename, ini_filename_byteCount);
-                native_ini_filename[native_ini_filename_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_ini_filename = null; }
-            ImGuiNative.igSaveIniSettingsToDisk(native_ini_filename);
-            if (ini_filename_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                Util.Free(native_ini_filename);
-            }
-        }
-        public static string SaveIniSettingsToMemory()
-        {
-            uint* out_ini_size = null;
-            byte* ret = ImGuiNative.igSaveIniSettingsToMemory(out_ini_size);
-            return Util.StringFromPtr(ret);
-        }
-        public static string SaveIniSettingsToMemory(out uint out_ini_size)
-        {
-            fixed (uint* native_out_ini_size = &out_ini_size)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
             {
-                byte* ret = ImGuiNative.igSaveIniSettingsToMemory(native_out_ini_size);
-                return Util.StringFromPtr(ret);
+                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static bool Selectable(string label)
+#endif
+        public static bool SliderInt4(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9766,17 +25203,40 @@ public static bool Selectable(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte selected = 0;
-            ImGuiSelectableFlags flags = 0;
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igSelectable(native_label, selected, flags, size);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                Util.Free(native_label);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (int* native_v = &v)
+            {
+                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool Selectable(string label, bool selected)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9796,17 +25256,20 @@ public static bool Selectable(string label, bool selected)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_selected = selected ? (byte)1 : (byte)0;
-            ImGuiSelectableFlags flags = 0;
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igSelectable(native_label, native_selected, flags, size);
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags)
+#endif
+        public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9826,16 +25289,20 @@ public static bool Selectable(string label, bool selected, ImGuiSelectableFlags
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_selected = selected ? (byte)1 : (byte)0;
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igSelectable(native_label, native_selected, flags, size);
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags, Vector2 size)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9855,15 +25322,41 @@ public static bool Selectable(string label, bool selected, ImGuiSelectableFlags
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_selected = selected ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.igSelectable(native_label, native_selected, flags, size);
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
             return ret != 0;
         }
-        public static bool Selectable(string label, ref bool p_selected)
+#endif
+        public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9883,19 +25376,41 @@ public static bool Selectable(string label, ref bool p_selected)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
-            byte* native_p_selected = &native_p_selected_val;
-            ImGuiSelectableFlags flags = 0;
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igSelectableBoolPtr(native_label, native_p_selected, flags, size);
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
-            p_selected = native_p_selected_val != 0;
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
             return ret != 0;
         }
-        public static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9915,18 +25430,40 @@ public static bool Selectable(string label, ref bool p_selected, ImGuiSelectable
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
-            byte* native_p_selected = &native_p_selected_val;
-            Vector2 size = new Vector2();
-            byte ret = ImGuiNative.igSelectableBoolPtr(native_label, native_p_selected, flags, size);
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
-            p_selected = native_p_selected_val != 0;
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
             return ret != 0;
         }
-        public static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags, Vector2 size)
+#endif
+        public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -9946,562 +25483,439 @@ public static bool Selectable(string label, ref bool p_selected, ImGuiSelectable
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte native_p_selected_val = p_selected ? (byte)1 : (byte)0;
-            byte* native_p_selected = &native_p_selected_val;
-            byte ret = ImGuiNative.igSelectableBoolPtr(native_label, native_p_selected, flags, size);
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
-            p_selected = native_p_selected_val != 0;
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
             return ret != 0;
         }
-        public static void Separator()
-        {
-            ImGuiNative.igSeparator();
-        }
-        public static void SetClipboardText(string text)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max)
         {
-            byte* native_text;
-            int text_byteCount = 0;
-            if (text != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                text_byteCount = Encoding.UTF8.GetByteCount(text);
-                if (text_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_text = Util.Allocate(text_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
-                    native_text = native_text_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
-                native_text[native_text_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_text = null; }
-            ImGuiNative.igSetClipboardText(native_text);
-            if (text_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_p_data, components, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_text);
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static void SetColorEditOptions(ImGuiColorEditFlags flags)
-        {
-            ImGuiNative.igSetColorEditOptions(flags);
-        }
-        public static void SetColumnOffset(int column_index, float offset_x)
-        {
-            ImGuiNative.igSetColumnOffset(column_index, offset_x);
-        }
-        public static void SetColumnWidth(int column_index, float width)
-        {
-            ImGuiNative.igSetColumnWidth(column_index, width);
-        }
-        public static void SetCurrentContext(IntPtr ctx)
-        {
-            ImGuiNative.igSetCurrentContext(ctx);
-        }
-        public static void SetCursorPos(Vector2 local_pos)
-        {
-            ImGuiNative.igSetCursorPos(local_pos);
-        }
-        public static void SetCursorPosX(float local_x)
-        {
-            ImGuiNative.igSetCursorPosX(local_x);
-        }
-        public static void SetCursorPosY(float local_y)
-        {
-            ImGuiNative.igSetCursorPosY(local_y);
-        }
-        public static void SetCursorScreenPos(Vector2 pos)
-        {
-            ImGuiNative.igSetCursorScreenPos(pos);
-        }
-        public static bool SetDragDropPayload(string type, IntPtr data, uint size)
+#endif
+        public static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max)
         {
-            byte* native_type;
-            int type_byteCount = 0;
-            if (type != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                type_byteCount = Encoding.UTF8.GetByteCount(type);
-                if (type_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_type = Util.Allocate(type_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
-                    native_type = native_type_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
-                native_type[native_type_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_type = null; }
-            void* native_data = (void*)data.ToPointer();
-            ImGuiCond cond = 0;
-            byte ret = ImGuiNative.igSetDragDropPayload(native_type, native_data, size, cond);
-            if (type_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_p_data, components, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_type);
+                Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static bool SetDragDropPayload(string type, IntPtr data, uint size, ImGuiCond cond)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
         {
-            byte* native_type;
-            int type_byteCount = 0;
-            if (type != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                type_byteCount = Encoding.UTF8.GetByteCount(type);
-                if (type_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_type = Util.Allocate(type_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
-                    native_type = native_type_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
-                native_type[native_type_offset] = 0;
-            }
-            else { native_type = null; }
-            void* native_data = (void*)data.ToPointer();
-            byte ret = ImGuiNative.igSetDragDropPayload(native_type, native_data, size, cond);
-            if (type_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_type);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            return ret != 0;
-        }
-        public static void SetItemAllowOverlap()
-        {
-            ImGuiNative.igSetItemAllowOverlap();
-        }
-        public static void SetItemDefaultFocus()
-        {
-            ImGuiNative.igSetItemDefaultFocus();
-        }
-        public static void SetKeyboardFocusHere()
-        {
-            int offset = 0;
-            ImGuiNative.igSetKeyboardFocusHere(offset);
-        }
-        public static void SetKeyboardFocusHere(int offset)
-        {
-            ImGuiNative.igSetKeyboardFocusHere(offset);
-        }
-        public static void SetMouseCursor(ImGuiMouseCursor type)
-        {
-            ImGuiNative.igSetMouseCursor(type);
-        }
-        public static void SetNextTreeNodeOpen(bool is_open)
-        {
-            byte native_is_open = is_open ? (byte)1 : (byte)0;
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetNextTreeNodeOpen(native_is_open, cond);
-        }
-        public static void SetNextTreeNodeOpen(bool is_open, ImGuiCond cond)
-        {
-            byte native_is_open = is_open ? (byte)1 : (byte)0;
-            ImGuiNative.igSetNextTreeNodeOpen(native_is_open, cond);
-        }
-        public static void SetNextWindowBgAlpha(float alpha)
-        {
-            ImGuiNative.igSetNextWindowBgAlpha(alpha);
-        }
-        public static void SetNextWindowCollapsed(bool collapsed)
-        {
-            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetNextWindowCollapsed(native_collapsed, cond);
-        }
-        public static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
-        {
-            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
-            ImGuiNative.igSetNextWindowCollapsed(native_collapsed, cond);
-        }
-        public static void SetNextWindowContentSize(Vector2 size)
-        {
-            ImGuiNative.igSetNextWindowContentSize(size);
-        }
-        public static void SetNextWindowFocus()
-        {
-            ImGuiNative.igSetNextWindowFocus();
-        }
-        public static void SetNextWindowPos(Vector2 pos)
-        {
-            ImGuiCond cond = 0;
-            Vector2 pivot = new Vector2();
-            ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
-        }
-        public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond)
-        {
-            Vector2 pivot = new Vector2();
-            ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
-        }
-        public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond, Vector2 pivot)
-        {
-            ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
-        }
-        public static void SetNextWindowSize(Vector2 size)
-        {
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetNextWindowSize(size, cond);
-        }
-        public static void SetNextWindowSize(Vector2 size, ImGuiCond cond)
-        {
-            ImGuiNative.igSetNextWindowSize(size, cond);
-        }
-        public static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max)
-        {
-            ImGuiSizeCallback custom_callback = null;
-            void* custom_callback_data = null;
-            ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data);
-        }
-        public static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback)
-        {
-            void* custom_callback_data = null;
-            ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data);
-        }
-        public static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback, IntPtr custom_callback_data)
-        {
-            void* native_custom_callback_data = (void*)custom_callback_data.ToPointer();
-            ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, native_custom_callback_data);
-        }
-        public static void SetScrollFromPosY(float local_y)
-        {
-            float center_y_ratio = 0.5f;
-            ImGuiNative.igSetScrollFromPosY(local_y, center_y_ratio);
-        }
-        public static void SetScrollFromPosY(float local_y, float center_y_ratio)
-        {
-            ImGuiNative.igSetScrollFromPosY(local_y, center_y_ratio);
-        }
-        public static void SetScrollHereY()
-        {
-            float center_y_ratio = 0.5f;
-            ImGuiNative.igSetScrollHereY(center_y_ratio);
-        }
-        public static void SetScrollHereY(float center_y_ratio)
-        {
-            ImGuiNative.igSetScrollHereY(center_y_ratio);
-        }
-        public static void SetScrollX(float scroll_x)
-        {
-            ImGuiNative.igSetScrollX(scroll_x);
-        }
-        public static void SetScrollY(float scroll_y)
-        {
-            ImGuiNative.igSetScrollY(scroll_y);
-        }
-        public static void SetStateStorage(ImGuiStoragePtr storage)
-        {
-            ImGuiStorage* native_storage = storage.NativePtr;
-            ImGuiNative.igSetStateStorage(native_storage);
-        }
-        public static void SetTabItemClosed(string tab_or_docked_window_label)
-        {
-            byte* native_tab_or_docked_window_label;
-            int tab_or_docked_window_label_byteCount = 0;
-            if (tab_or_docked_window_label != null)
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                tab_or_docked_window_label_byteCount = Encoding.UTF8.GetByteCount(tab_or_docked_window_label);
-                if (tab_or_docked_window_label_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_tab_or_docked_window_label = Util.Allocate(tab_or_docked_window_label_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_tab_or_docked_window_label_stackBytes = stackalloc byte[tab_or_docked_window_label_byteCount + 1];
-                    native_tab_or_docked_window_label = native_tab_or_docked_window_label_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_tab_or_docked_window_label_offset = Util.GetUtf8(tab_or_docked_window_label, native_tab_or_docked_window_label, tab_or_docked_window_label_byteCount);
-                native_tab_or_docked_window_label[native_tab_or_docked_window_label_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_tab_or_docked_window_label = null; }
-            ImGuiNative.igSetTabItemClosed(native_tab_or_docked_window_label);
-            if (tab_or_docked_window_label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_p_data, components, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_tab_or_docked_window_label);
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
             }
+            return ret != 0;
         }
-        public static void SetTooltip(string fmt)
+#endif
+        public static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, string format)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            ImGuiNative.igSetTooltip(native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_fmt);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-        }
-        public static void SetWindowCollapsed(bool collapsed)
-        {
-            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetWindowCollapsedBool(native_collapsed, cond);
-        }
-        public static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
-        {
-            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
-            ImGuiNative.igSetWindowCollapsedBool(native_collapsed, cond);
-        }
-        public static void SetWindowCollapsed(string name, bool collapsed)
-        {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_name = null; }
-            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetWindowCollapsedStr(native_name, native_collapsed, cond);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_p_data, components, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
             }
+            return ret != 0;
         }
-        public static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SliderScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
-            {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
-            }
-            else { native_name = null; }
-            byte native_collapsed = collapsed ? (byte)1 : (byte)0;
-            ImGuiNative.igSetWindowCollapsedStr(native_name, native_collapsed, cond);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_name);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-        }
-        public static void SetWindowFocus()
-        {
-            ImGuiNative.igSetWindowFocus();
-        }
-        public static void SetWindowFocus(string name)
-        {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_name = null; }
-            ImGuiNative.igSetWindowFocusStr(native_name);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_p_data, components, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_label);
             }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
         }
-        public static void SetWindowFontScale(float scale)
-        {
-            ImGuiNative.igSetWindowFontScale(scale);
-        }
-        public static void SetWindowPos(Vector2 pos)
-        {
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetWindowPosVec2(pos, cond);
-        }
-        public static void SetWindowPos(Vector2 pos, ImGuiCond cond)
-        {
-            ImGuiNative.igSetWindowPosVec2(pos, cond);
-        }
-        public static void SetWindowPos(string name, Vector2 pos)
+#endif
+        public static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
-            }
-            else { native_name = null; }
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetWindowPosStr(native_name, pos, cond);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_name);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-        }
-        public static void SetWindowPos(string name, Vector2 pos, ImGuiCond cond)
-        {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_name = null; }
-            ImGuiNative.igSetWindowPosStr(native_name, pos, cond);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_format = null; }
+            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_p_data, components, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_label);
             }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
         }
-        public static void SetWindowSize(Vector2 size)
-        {
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetWindowSizeVec2(size, cond);
-        }
-        public static void SetWindowSize(Vector2 size, ImGuiCond cond)
-        {
-            ImGuiNative.igSetWindowSizeVec2(size, cond);
-        }
-        public static void SetWindowSize(string name, Vector2 size)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool SmallButton(ReadOnlySpan<char> label)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_name = null; }
-            ImGuiCond cond = 0;
-            ImGuiNative.igSetWindowSizeStr(native_name, size, cond);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            byte ret = ImGuiNative.igSmallButton(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static void SetWindowSize(string name, Vector2 size, ImGuiCond cond)
+#endif
+        public static bool SmallButton(string label)
         {
-            byte* native_name;
-            int name_byteCount = 0;
-            if (name != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                name_byteCount = Encoding.UTF8.GetByteCount(name);
-                if (name_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_name = Util.Allocate(name_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
-                    native_name = native_name_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
-                native_name[native_name_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_name = null; }
-            ImGuiNative.igSetWindowSizeStr(native_name, size, cond);
-            if (name_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            byte ret = ImGuiNative.igSmallButton(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_name);
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static void ShowAboutWindow()
+        public static void Spacing()
         {
-            byte* p_open = null;
-            ImGuiNative.igShowAboutWindow(p_open);
+            ImGuiNative.igSpacing();
         }
-        public static void ShowAboutWindow(ref bool p_open)
+        public static void StyleColorsClassic()
         {
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            ImGuiNative.igShowAboutWindow(native_p_open);
-            p_open = native_p_open_val != 0;
+            ImGuiStyle* dst = null;
+            ImGuiNative.igStyleColorsClassic(dst);
         }
-        public static void ShowDemoWindow()
+        public static void StyleColorsClassic(ImGuiStylePtr dst)
         {
-            byte* p_open = null;
-            ImGuiNative.igShowDemoWindow(p_open);
+            ImGuiStyle* native_dst = dst.NativePtr;
+            ImGuiNative.igStyleColorsClassic(native_dst);
         }
-        public static void ShowDemoWindow(ref bool p_open)
+        public static void StyleColorsDark()
         {
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            ImGuiNative.igShowDemoWindow(native_p_open);
-            p_open = native_p_open_val != 0;
+            ImGuiStyle* dst = null;
+            ImGuiNative.igStyleColorsDark(dst);
+        }
+        public static void StyleColorsDark(ImGuiStylePtr dst)
+        {
+            ImGuiStyle* native_dst = dst.NativePtr;
+            ImGuiNative.igStyleColorsDark(native_dst);
+        }
+        public static void StyleColorsLight()
+        {
+            ImGuiStyle* dst = null;
+            ImGuiNative.igStyleColorsLight(dst);
+        }
+        public static void StyleColorsLight(ImGuiStylePtr dst)
+        {
+            ImGuiStyle* native_dst = dst.NativePtr;
+            ImGuiNative.igStyleColorsLight(native_dst);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TabItemButton(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiTabItemFlags flags = (ImGuiTabItemFlags)0;
+            byte ret = ImGuiNative.igTabItemButton(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
         }
-        public static void ShowFontSelector(string label)
+#endif
+        public static bool TabItemButton(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10521,35 +25935,16 @@ public static void ShowFontSelector(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiNative.igShowFontSelector(native_label);
+            ImGuiTabItemFlags flags = (ImGuiTabItemFlags)0;
+            byte ret = ImGuiNative.igTabItemButton(native_label, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static void ShowMetricsWindow()
-        {
-            byte* p_open = null;
-            ImGuiNative.igShowMetricsWindow(p_open);
-        }
-        public static void ShowMetricsWindow(ref bool p_open)
-        {
-            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
-            byte* native_p_open = &native_p_open_val;
-            ImGuiNative.igShowMetricsWindow(native_p_open);
-            p_open = native_p_open_val != 0;
-        }
-        public static void ShowStyleEditor()
-        {
-            ImGuiStyle* @ref = null;
-            ImGuiNative.igShowStyleEditor(@ref);
-        }
-        public static void ShowStyleEditor(ImGuiStylePtr @ref)
-        {
-            ImGuiStyle* native_ref = @ref.NativePtr;
-            ImGuiNative.igShowStyleEditor(native_ref);
-        }
-        public static bool ShowStyleSelector(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TabItemButton(ReadOnlySpan<char> label, ImGuiTabItemFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10569,18 +25964,15 @@ public static bool ShowStyleSelector(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte ret = ImGuiNative.igShowStyleSelector(native_label);
+            byte ret = ImGuiNative.igTabItemButton(native_label, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static void ShowUserGuide()
-        {
-            ImGuiNative.igShowUserGuide();
-        }
-        public static bool SliderAngle(string label, ref float v_rad)
+#endif
+        public static bool TabItemButton(string label, ImGuiTabItemFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10600,37 +25992,66 @@ public static bool SliderAngle(string label, ref float v_rad)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_degrees_min = -360.0f;
-            float v_degrees_max = +360.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (float* native_v_rad = &v_rad)
+            byte ret = ImGuiNative.igTabItemButton(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min)
+        public static void TableAngledHeadersRow()
+        {
+            ImGuiNative.igTableAngledHeadersRow();
+        }
+        public static int TableGetColumnCount()
+        {
+            int ret = ImGuiNative.igTableGetColumnCount();
+            return ret;
+        }
+        public static ImGuiTableColumnFlags TableGetColumnFlags()
+        {
+            int column_n = -1;
+            ImGuiTableColumnFlags ret = ImGuiNative.igTableGetColumnFlags(column_n);
+            return ret;
+        }
+        public static ImGuiTableColumnFlags TableGetColumnFlags(int column_n)
+        {
+            ImGuiTableColumnFlags ret = ImGuiNative.igTableGetColumnFlags(column_n);
+            return ret;
+        }
+        public static int TableGetColumnIndex()
+        {
+            int ret = ImGuiNative.igTableGetColumnIndex();
+            return ret;
+        }
+        public static string TableGetColumnName()
+        {
+            int column_n = -1;
+            byte* ret = ImGuiNative.igTableGetColumnName_Int(column_n);
+            return Util.StringFromPtr(ret);
+        }
+        public static string TableGetColumnName(int column_n)
+        {
+            byte* ret = ImGuiNative.igTableGetColumnName_Int(column_n);
+            return Util.StringFromPtr(ret);
+        }
+        public static int TableGetHoveredColumn()
+        {
+            int ret = ImGuiNative.igTableGetHoveredColumn();
+            return ret;
+        }
+        public static int TableGetRowIndex()
+        {
+            int ret = ImGuiNative.igTableGetRowIndex();
+            return ret;
+        }
+        public static ImGuiTableSortSpecsPtr TableGetSortSpecs()
+        {
+            ImGuiTableSortSpecs* ret = ImGuiNative.igTableGetSortSpecs();
+            return new ImGuiTableSortSpecsPtr(ret);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TableHeader(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10650,36 +26071,14 @@ public static bool SliderAngle(string label, ref float v_rad, float v_degrees_mi
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            float v_degrees_max = +360.0f;
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (float* native_v_rad = &v_rad)
+            ImGuiNative.igTableHeader(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max)
+#endif
+        public static void TableHeader(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10699,35 +26098,57 @@ public static bool SliderAngle(string label, ref float v_rad, float v_degrees_mi
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.0f deg");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.0f deg", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (float* native_v_rad = &v_rad)
+            ImGuiNative.igTableHeader(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max, string format)
+        public static void TableHeadersRow()
+        {
+            ImGuiNative.igTableHeadersRow();
+        }
+        public static bool TableNextColumn()
+        {
+            byte ret = ImGuiNative.igTableNextColumn();
+            return ret != 0;
+        }
+        public static void TableNextRow()
+        {
+            ImGuiTableRowFlags row_flags = (ImGuiTableRowFlags)0;
+            float min_row_height = 0.0f;
+            ImGuiNative.igTableNextRow(row_flags, min_row_height);
+        }
+        public static void TableNextRow(ImGuiTableRowFlags row_flags)
+        {
+            float min_row_height = 0.0f;
+            ImGuiNative.igTableNextRow(row_flags, min_row_height);
+        }
+        public static void TableNextRow(ImGuiTableRowFlags row_flags, float min_row_height)
+        {
+            ImGuiNative.igTableNextRow(row_flags, min_row_height);
+        }
+        public static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
+        {
+            int column_n = -1;
+            ImGuiNative.igTableSetBgColor(target, color, column_n);
+        }
+        public static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int column_n)
+        {
+            ImGuiNative.igTableSetBgColor(target, color, column_n);
+        }
+        public static void TableSetColumnEnabled(int column_n, bool v)
+        {
+            byte native_v = v ? (byte)1 : (byte)0;
+            ImGuiNative.igTableSetColumnEnabled(column_n, native_v);
+        }
+        public static bool TableSetColumnIndex(int column_n)
+        {
+            byte ret = ImGuiNative.igTableSetColumnIndex(column_n);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TableSetupColumn(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10747,39 +26168,17 @@ public static bool SliderAngle(string label, ref float v_rad, float v_degrees_mi
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (float* native_v_rad = &v_rad)
+            ImGuiTableColumnFlags flags = (ImGuiTableColumnFlags)0;
+            float init_width_or_weight = 0.0f;
+            uint user_id = 0;
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderAngle(native_label, native_v_rad, v_degrees_min, v_degrees_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat(string label, ref float v, float v_min, float v_max)
+#endif
+        public static void TableSetupColumn(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10799,36 +26198,17 @@ public static bool SliderFloat(string label, ref float v, float v_min, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            ImGuiTableColumnFlags flags = (ImGuiTableColumnFlags)0;
+            float init_width_or_weight = 0.0f;
+            uint user_id = 0;
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat(string label, ref float v, float v_min, float v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TableSetupColumn(ReadOnlySpan<char> label, ImGuiTableColumnFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10848,40 +26228,16 @@ public static bool SliderFloat(string label, ref float v, float v_min, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (float* native_v = &v)
-            {
-                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+            float init_width_or_weight = 0.0f;
+            uint user_id = 0;
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat(string label, ref float v, float v_min, float v_max, string format, float power)
+#endif
+        public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10901,39 +26257,16 @@ public static bool SliderFloat(string label, ref float v, float v_min, float v_m
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (float* native_v = &v)
+            float init_width_or_weight = 0.0f;
+            uint user_id = 0;
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TableSetupColumn(ReadOnlySpan<char> label, ImGuiTableColumnFlags flags, float init_width_or_weight)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -10953,36 +26286,15 @@ public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+            uint user_id = 0;
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max, string format)
+#endif
+        public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float init_width_or_weight)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11002,40 +26314,42 @@ public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            uint user_id = 0;
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                Util.Free(native_label);
             }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (Vector2* native_v = &v)
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TableSetupColumn(ReadOnlySpan<char> label, ImGuiTableColumnFlags flags, float init_width_or_weight, uint user_id)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, power);
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                return ret != 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max, string format, float power)
+#endif
+        public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float init_width_or_weight, uint user_id)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11055,88 +26369,180 @@ public static bool SliderFloat2(string label, ref Vector2 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            ImGuiNative.igTableSetupColumn(native_label, flags, init_width_or_weight, user_id);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_label);
+            }
+        }
+        public static void TableSetupScrollFreeze(int cols, int rows)
+        {
+            ImGuiNative.igTableSetupScrollFreeze(cols, rows);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Text(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (Vector2* native_v = &v)
+            else { native_fmt = null; }
+            ImGuiNative.igText(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat2(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void Text(string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                return ret != 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igText(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
         }
-        public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TextColored(Vector4 col, ReadOnlySpan<char> fmt)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_fmt = null; }
+            ImGuiNative.igTextColored(col, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void TextColored(Vector4 col, string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igTextColored(col, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_fmt);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TextDisabled(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igTextDisabled(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void TextDisabled(string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                return ret != 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igTextDisabled(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
         }
-        public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TextLink(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11156,40 +26562,15 @@ public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (Vector3* native_v = &v)
+            byte ret = ImGuiNative.igTextLink(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max, string format, float power)
+#endif
+        public static bool TextLink(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11209,39 +26590,15 @@ public static bool SliderFloat3(string label, ref Vector3 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (Vector3* native_v = &v)
+            byte ret = ImGuiNative.igTextLink(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat3(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TextLinkOpenURL(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11261,36 +26618,15 @@ public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            byte* native_url = null;
+            ImGuiNative.igTextLinkOpenURL(native_label, native_url);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max, string format)
+#endif
+        public static void TextLinkOpenURL(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11310,40 +26646,15 @@ public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            fixed (Vector4* native_v = &v)
+            byte* native_url = null;
+            ImGuiNative.igTextLinkOpenURL(native_label, native_url);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
         }
-        public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max, string format, float power)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TextLinkOpenURL(ReadOnlySpan<char> label, ReadOnlySpan<char> url)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11363,39 +26674,36 @@ public static bool SliderFloat4(string label, ref Vector4 v, float v_min, float
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            byte* native_url;
+            int url_byteCount = 0;
+            if (url != null)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                url_byteCount = Encoding.UTF8.GetByteCount(url);
+                if (url_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_url = Util.Allocate(url_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_url_stackBytes = stackalloc byte[url_byteCount + 1];
+                    native_url = native_url_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_url_offset = Util.GetUtf8(url, native_url, url_byteCount);
+                native_url[native_url_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (Vector4* native_v = &v)
+            else { native_url = null; }
+            ImGuiNative.igTextLinkOpenURL(native_label, native_url);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderFloat4(native_label, native_v, v_min, v_max, native_format, power);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
+            }
+            if (url_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_url);
             }
         }
-        public static bool SliderInt(string label, ref int v, int v_min, int v_max)
+#endif
+        public static void TextLinkOpenURL(string label, string url)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11415,87 +26723,144 @@ public static bool SliderInt(string label, ref int v, int v_min, int v_max)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_url;
+            int url_byteCount = 0;
+            if (url != null)
+            {
+                url_byteCount = Encoding.UTF8.GetByteCount(url);
+                if (url_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_url = Util.Allocate(url_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_url_stackBytes = stackalloc byte[url_byteCount + 1];
+                    native_url = native_url_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+                int native_url_offset = Util.GetUtf8(url, native_url, url_byteCount);
+                native_url[native_url_offset] = 0;
+            }
+            else { native_url = null; }
+            ImGuiNative.igTextLinkOpenURL(native_label, native_url);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_label);
+            }
+            if (url_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_url);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TextUnformatted(ReadOnlySpan<char> text)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                return ret != 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.igTextUnformatted(native_text, native_text+text_byteCount);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
             }
         }
-        public static bool SliderInt(string label, ref int v, int v_min, int v_max, string format)
+#endif
+        public static void TextUnformatted(string text)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_text = Util.Allocate(text_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_text = null; }
+            ImGuiNative.igTextUnformatted(native_text, native_text+text_byteCount);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TextWrapped(ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImGuiNative.igTextWrapped(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void TextWrapped(string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            else { native_fmt = null; }
+            ImGuiNative.igTextWrapped(native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_fmt);
             }
         }
-        public static bool SliderInt2(string label, ref int v, int v_min, int v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNode(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11515,35 +26880,15 @@ public static bool SliderInt2(string label, ref int v, int v_min, int v_max)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            byte ret = ImGuiNative.igTreeNode_Str(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool SliderInt2(string label, ref int v, int v_min, int v_max, string format)
+#endif
+        public static bool TreeNode(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11563,139 +26908,173 @@ public static bool SliderInt2(string label, ref int v, int v_min, int v_max, str
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            byte ret = ImGuiNative.igTreeNode_Str(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNode(ReadOnlySpan<char> str_id, ReadOnlySpan<char> fmt)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            else { native_str_id = null; }
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
             {
-                byte ret = ImGuiNative.igSliderInt2(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    Util.Free(native_label);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                else
                 {
-                    Util.Free(native_format);
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                return ret != 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNode_StrStr(native_str_id, native_fmt);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
+            return ret != 0;
         }
-        public static bool SliderInt3(string label, ref int v, int v_min, int v_max)
+#endif
+        public static bool TreeNode(string str_id, string fmt)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNode_StrStr(native_str_id, native_fmt);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_str_id);
+            }
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
+            return ret != 0;
         }
-        public static bool SliderInt3(string label, ref int v, int v_min, int v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNode(IntPtr ptr_id, ReadOnlySpan<char> fmt)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNode_Ptr(native_ptr_id, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_fmt);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool TreeNode(IntPtr ptr_id, string fmt)
+        {
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNode_Ptr(native_ptr_id, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt3(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_fmt);
             }
+            return ret != 0;
         }
-        public static bool SliderInt4(string label, ref int v, int v_min, int v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNodeEx(ReadOnlySpan<char> label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11715,35 +27094,16 @@ public static bool SliderInt4(string label, ref int v, int v_min, int v_max)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            fixed (int* native_v = &v)
+            ImGuiTreeNodeFlags flags = (ImGuiTreeNodeFlags)0;
+            byte ret = ImGuiNative.igTreeNodeEx_Str(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool SliderInt4(string label, ref int v, int v_min, int v_max, string format)
+#endif
+        public static bool TreeNodeEx(string label)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11763,39 +27123,16 @@ public static bool SliderInt4(string label, ref int v, int v_min, int v_max, str
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
-            {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    native_format = Util.Allocate(format_byteCount + 1);
-                }
-                else
-                {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
-                }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            fixed (int* native_v = &v)
+            ImGuiTreeNodeFlags flags = (ImGuiTreeNodeFlags)0;
+            byte ret = ImGuiNative.igTreeNodeEx_Str(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                byte ret = ImGuiNative.igSliderInt4(native_label, native_v, v_min, v_max, native_format);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_label);
-                }
-                if (format_byteCount > Util.StackAllocationSizeLimit)
-                {
-                    Util.Free(native_format);
-                }
-                return ret != 0;
+                Util.Free(native_label);
             }
+            return ret != 0;
         }
-        public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr v_min, IntPtr v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNodeEx(ReadOnlySpan<char> label, ImGuiTreeNodeFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11815,19 +27152,15 @@ public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_v, native_v_min, native_v_max, native_format, power);
+            byte ret = ImGuiNative.igTreeNodeEx_Str(native_label, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
-        public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr v_min, IntPtr v_max, string format)
+#endif
+        public static bool TreeNodeEx(string label, ImGuiTreeNodeFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -11847,425 +27180,567 @@ public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr v,
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            byte ret = ImGuiNative.igTreeNodeEx_Str(native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNodeEx(ReadOnlySpan<char> str_id, ImGuiTreeNodeFlags flags, ReadOnlySpan<char> fmt)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_format = null; }
-            float power = 1.0f;
-            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_v, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
             {
-                Util.Free(native_label);
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
             }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNodeEx_StrStr(native_str_id, flags, native_fmt);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_format);
+                Util.Free(native_str_id);
+            }
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
             }
             return ret != 0;
         }
-        public static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr v, IntPtr v_min, IntPtr v_max, string format, float power)
+#endif
+        public static bool TreeNodeEx(string str_id, ImGuiTreeNodeFlags flags, string fmt)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_str_id = null; }
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNodeEx_StrStr(native_str_id, flags, native_fmt);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool TreeNodeEx(IntPtr ptr_id, ImGuiTreeNodeFlags flags, ReadOnlySpan<char> fmt)
+        {
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNodeEx_Ptr(native_ptr_id, flags, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool TreeNodeEx(IntPtr ptr_id, ImGuiTreeNodeFlags flags, string fmt)
+        {
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            byte ret = ImGuiNative.igTreeNodeEx_Ptr(native_ptr_id, flags, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+            return ret != 0;
+        }
+        public static void TreePop()
+        {
+            ImGuiNative.igTreePop();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TreePush(ReadOnlySpan<char> str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
+            {
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
+                }
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
+            }
+            else { native_str_id = null; }
+            ImGuiNative.igTreePush_Str(native_str_id);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str_id);
+            }
+        }
+#endif
+        public static void TreePush(string str_id)
+        {
+            byte* native_str_id;
+            int str_id_byteCount = 0;
+            if (str_id != null)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
+                if (str_id_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_str_id = Util.Allocate(str_id_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
+                    native_str_id = native_str_id_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            byte ret = ImGuiNative.igSliderScalar(native_label, data_type, native_v, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
+                native_str_id[native_str_id_offset] = 0;
             }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_str_id = null; }
+            ImGuiNative.igTreePush_Str(native_str_id);
+            if (str_id_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_format);
+                Util.Free(native_str_id);
             }
-            return ret != 0;
         }
-        public static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr v_min, IntPtr v_max)
+        public static void TreePush(IntPtr ptr_id)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            void* native_ptr_id = (void*)ptr_id.ToPointer();
+            ImGuiNative.igTreePush_Ptr(native_ptr_id);
+        }
+        public static void Unindent()
+        {
+            float indent_w = 0.0f;
+            ImGuiNative.igUnindent(indent_w);
+        }
+        public static void Unindent(float indent_w)
+        {
+            ImGuiNative.igUnindent(indent_w);
+        }
+        public static void UpdatePlatformWindows()
+        {
+            ImGuiNative.igUpdatePlatformWindows();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Value(ReadOnlySpan<char> prefix, bool b)
+        {
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_v, components, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            byte native_b = b ? (byte)1 : (byte)0;
+            ImGuiNative.igValue_Bool(native_prefix, native_b);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_prefix);
             }
-            return ret != 0;
         }
-        public static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr v_min, IntPtr v_max, string format)
+#endif
+        public static void Value(string prefix, bool b)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_prefix = null; }
+            byte native_b = b ? (byte)1 : (byte)0;
+            ImGuiNative.igValue_Bool(native_prefix, native_b);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_prefix);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Value(ReadOnlySpan<char> prefix, int v)
+        {
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
+            {
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            float power = 1.0f;
-            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_v, components, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            ImGuiNative.igValue_Int(native_prefix, v);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_format);
+                Util.Free(native_prefix);
             }
-            return ret != 0;
         }
-        public static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr v, int components, IntPtr v_min, IntPtr v_max, string format, float power)
+#endif
+        public static void Value(string prefix, int v)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
-            byte* native_format;
-            int format_byteCount = 0;
-            if (format != null)
+            else { native_prefix = null; }
+            ImGuiNative.igValue_Int(native_prefix, v);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                format_byteCount = Encoding.UTF8.GetByteCount(format);
-                if (format_byteCount > Util.StackAllocationSizeLimit)
+                Util.Free(native_prefix);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Value(ReadOnlySpan<char> prefix, uint v)
+        {
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
+            {
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_format = Util.Allocate(format_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
-                    native_format = native_format_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
-                native_format[native_format_offset] = 0;
-            }
-            else { native_format = null; }
-            byte ret = ImGuiNative.igSliderScalarN(native_label, data_type, native_v, components, native_v_min, native_v_max, native_format, power);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            if (format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            ImGuiNative.igValue_Uint(native_prefix, v);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_format);
+                Util.Free(native_prefix);
             }
-            return ret != 0;
         }
-        public static bool SmallButton(string label)
+#endif
+        public static void Value(string prefix, uint v)
         {
-            byte* native_label;
-            int label_byteCount = 0;
-            if (label != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                label_byteCount = Encoding.UTF8.GetByteCount(label);
-                if (label_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_label = Util.Allocate(label_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
-                    native_label = native_label_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
-                native_label[native_label_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_label = null; }
-            byte ret = ImGuiNative.igSmallButton(native_label);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            ImGuiNative.igValue_Uint(native_prefix, v);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_label);
+                Util.Free(native_prefix);
             }
-            return ret != 0;
-        }
-        public static void Spacing()
-        {
-            ImGuiNative.igSpacing();
-        }
-        public static void StyleColorsClassic()
-        {
-            ImGuiStyle* dst = null;
-            ImGuiNative.igStyleColorsClassic(dst);
-        }
-        public static void StyleColorsClassic(ImGuiStylePtr dst)
-        {
-            ImGuiStyle* native_dst = dst.NativePtr;
-            ImGuiNative.igStyleColorsClassic(native_dst);
-        }
-        public static void StyleColorsDark()
-        {
-            ImGuiStyle* dst = null;
-            ImGuiNative.igStyleColorsDark(dst);
         }
-        public static void StyleColorsDark(ImGuiStylePtr dst)
-        {
-            ImGuiStyle* native_dst = dst.NativePtr;
-            ImGuiNative.igStyleColorsDark(native_dst);
-        }
-        public static void StyleColorsLight()
-        {
-            ImGuiStyle* dst = null;
-            ImGuiNative.igStyleColorsLight(dst);
-        }
-        public static void StyleColorsLight(ImGuiStylePtr dst)
-        {
-            ImGuiStyle* native_dst = dst.NativePtr;
-            ImGuiNative.igStyleColorsLight(native_dst);
-        }
-        public static void Text(string fmt)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Value(ReadOnlySpan<char> prefix, float v)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_fmt = null; }
-            ImGuiNative.igText(native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            byte* native_float_format = null;
+            ImGuiNative.igValue_Float(native_prefix, v, native_float_format);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_fmt);
+                Util.Free(native_prefix);
             }
         }
-        public static void TextColored(Vector4 col, string fmt)
+#endif
+        public static void Value(string prefix, float v)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_fmt = null; }
-            ImGuiNative.igTextColored(col, native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            byte* native_float_format = null;
+            ImGuiNative.igValue_Float(native_prefix, v, native_float_format);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_fmt);
+                Util.Free(native_prefix);
             }
         }
-        public static void TextDisabled(string fmt)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Value(ReadOnlySpan<char> prefix, float v, ReadOnlySpan<char> float_format)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            ImGuiNative.igTextDisabled(native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_fmt);
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-        }
-        public static void TextUnformatted(string text)
-        {
-            byte* native_text;
-            int text_byteCount = 0;
-            if (text != null)
+            else { native_prefix = null; }
+            byte* native_float_format;
+            int float_format_byteCount = 0;
+            if (float_format != null)
             {
-                text_byteCount = Encoding.UTF8.GetByteCount(text);
-                if (text_byteCount > Util.StackAllocationSizeLimit)
+                float_format_byteCount = Encoding.UTF8.GetByteCount(float_format);
+                if (float_format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_text = Util.Allocate(text_byteCount + 1);
+                    native_float_format = Util.Allocate(float_format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
-                    native_text = native_text_stackBytes;
+                    byte* native_float_format_stackBytes = stackalloc byte[float_format_byteCount + 1];
+                    native_float_format = native_float_format_stackBytes;
                 }
-                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
-                native_text[native_text_offset] = 0;
+                int native_float_format_offset = Util.GetUtf8(float_format, native_float_format, float_format_byteCount);
+                native_float_format[native_float_format_offset] = 0;
             }
-            else { native_text = null; }
-            byte* native_text_end = null;
-            ImGuiNative.igTextUnformatted(native_text, native_text_end);
-            if (text_byteCount > Util.StackAllocationSizeLimit)
+            else { native_float_format = null; }
+            ImGuiNative.igValue_Float(native_prefix, v, native_float_format);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
             {
-                Util.Free(native_text);
+                Util.Free(native_prefix);
+            }
+            if (float_format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_float_format);
             }
         }
-        public static void TextWrapped(string fmt)
+#endif
+        public static void Value(string prefix, float v, string float_format)
         {
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_prefix;
+            int prefix_byteCount = 0;
+            if (prefix != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
+                if (prefix_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_prefix = Util.Allocate(prefix_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
+                    native_prefix = native_prefix_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
+                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
+                native_prefix[native_prefix_offset] = 0;
             }
-            else { native_fmt = null; }
-            ImGuiNative.igTextWrapped(native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            else { native_prefix = null; }
+            byte* native_float_format;
+            int float_format_byteCount = 0;
+            if (float_format != null)
             {
-                Util.Free(native_fmt);
+                float_format_byteCount = Encoding.UTF8.GetByteCount(float_format);
+                if (float_format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_float_format = Util.Allocate(float_format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_float_format_stackBytes = stackalloc byte[float_format_byteCount + 1];
+                    native_float_format = native_float_format_stackBytes;
+                }
+                int native_float_format_offset = Util.GetUtf8(float_format, native_float_format, float_format_byteCount);
+                native_float_format[native_float_format_offset] = 0;
+            }
+            else { native_float_format = null; }
+            ImGuiNative.igValue_Float(native_prefix, v, native_float_format);
+            if (prefix_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_prefix);
+            }
+            if (float_format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_float_format);
             }
         }
-        public static void TreeAdvanceToLabelPos()
-        {
-            ImGuiNative.igTreeAdvanceToLabelPos();
-        }
-        public static bool TreeNode(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderFloat(ReadOnlySpan<char> label, Vector2 size, ref float v, float v_min, float v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12285,91 +27760,87 @@ public static bool TreeNode(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte ret = ImGuiNative.igTreeNodeStr(native_label);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            return ret != 0;
-        }
-        public static bool TreeNode(string str_id, string fmt)
-        {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
-            {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
-            }
-            else { native_str_id = null; }
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            byte ret = ImGuiNative.igTreeNodeStrStr(native_str_id, native_fmt);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
-            }
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_fmt);
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool TreeNode(IntPtr ptr_id, string fmt)
+#endif
+        public static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max)
         {
-            void* native_ptr_id = (void*)ptr_id.ToPointer();
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            byte ret = ImGuiNative.igTreeNodePtr(native_ptr_id, native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                Util.Free(native_fmt);
+                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool TreeNodeEx(string label)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderFloat(ReadOnlySpan<char> label, Vector2 size, ref float v, float v_min, float v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12389,15 +27860,41 @@ public static bool TreeNodeEx(string label)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            ImGuiTreeNodeFlags flags = 0;
-            byte ret = ImGuiNative.igTreeNodeExStr(native_label, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                Util.Free(native_label);
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
+            {
+                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool TreeNodeEx(string label, ImGuiTreeNodeFlags flags)
+#endif
+        public static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12417,294 +27914,197 @@ public static bool TreeNodeEx(string label, ImGuiTreeNodeFlags flags)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte ret = ImGuiNative.igTreeNodeExStr(native_label, flags);
-            if (label_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_label);
-            }
-            return ret != 0;
-        }
-        public static bool TreeNodeEx(string str_id, ImGuiTreeNodeFlags flags, string fmt)
-        {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-            else { native_str_id = null; }
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (float* native_v = &v)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            byte ret = ImGuiNative.igTreeNodeExStrStr(native_str_id, flags, native_fmt);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
-            }
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_fmt);
+                return ret != 0;
             }
-            return ret != 0;
         }
-        public static bool TreeNodeEx(IntPtr ptr_id, ImGuiTreeNodeFlags flags, string fmt)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderFloat(ReadOnlySpan<char> label, Vector2 size, ref float v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
-            void* native_ptr_id = (void*)ptr_id.ToPointer();
-            byte* native_fmt;
-            int fmt_byteCount = 0;
-            if (fmt != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
-                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
-                    native_fmt = native_fmt_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
-                native_fmt[native_fmt_offset] = 0;
-            }
-            else { native_fmt = null; }
-            byte ret = ImGuiNative.igTreeNodeExPtr(native_ptr_id, flags, native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_fmt);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            return ret != 0;
-        }
-        public static void TreePop()
-        {
-            ImGuiNative.igTreePop();
-        }
-        public static void TreePush(string str_id)
-        {
-            byte* native_str_id;
-            int str_id_byteCount = 0;
-            if (str_id != null)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                str_id_byteCount = Encoding.UTF8.GetByteCount(str_id);
-                if (str_id_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_str_id = Util.Allocate(str_id_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_str_id_stackBytes = stackalloc byte[str_id_byteCount + 1];
-                    native_str_id = native_str_id_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_str_id_offset = Util.GetUtf8(str_id, native_str_id, str_id_byteCount);
-                native_str_id[native_str_id_offset] = 0;
-            }
-            else { native_str_id = null; }
-            ImGuiNative.igTreePushStr(native_str_id);
-            if (str_id_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_str_id);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-        }
-        public static void TreePush()
-        {
-            void* ptr_id = null;
-            ImGuiNative.igTreePushPtr(ptr_id);
-        }
-        public static void TreePush(IntPtr ptr_id)
-        {
-            void* native_ptr_id = (void*)ptr_id.ToPointer();
-            ImGuiNative.igTreePushPtr(native_ptr_id);
-        }
-        public static void Unindent()
-        {
-            float indent_w = 0.0f;
-            ImGuiNative.igUnindent(indent_w);
-        }
-        public static void Unindent(float indent_w)
-        {
-            ImGuiNative.igUnindent(indent_w);
-        }
-        public static void Value(string prefix, bool b)
-        {
-            byte* native_prefix;
-            int prefix_byteCount = 0;
-            if (prefix != null)
+            else { native_format = null; }
+            fixed (float* native_v = &v)
             {
-                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
-                if (prefix_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_prefix = Util.Allocate(prefix_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
-                    native_prefix = native_prefix_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
-                native_prefix[native_prefix_offset] = 0;
-            }
-            else { native_prefix = null; }
-            byte native_b = b ? (byte)1 : (byte)0;
-            ImGuiNative.igValueBool(native_prefix, native_b);
-            if (prefix_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_prefix);
+                return ret != 0;
             }
         }
-        public static void Value(string prefix, int v)
+#endif
+        public static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
         {
-            byte* native_prefix;
-            int prefix_byteCount = 0;
-            if (prefix != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
-                if (prefix_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_prefix = Util.Allocate(prefix_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
-                    native_prefix = native_prefix_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
-                native_prefix[native_prefix_offset] = 0;
-            }
-            else { native_prefix = null; }
-            ImGuiNative.igValueInt(native_prefix, v);
-            if (prefix_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_prefix);
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-        }
-        public static void Value(string prefix, uint v)
-        {
-            byte* native_prefix;
-            int prefix_byteCount = 0;
-            if (prefix != null)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
             {
-                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
-                if (prefix_byteCount > Util.StackAllocationSizeLimit)
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_prefix = Util.Allocate(prefix_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
-                    native_prefix = native_prefix_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
-                native_prefix[native_prefix_offset] = 0;
-            }
-            else { native_prefix = null; }
-            ImGuiNative.igValueUint(native_prefix, v);
-            if (prefix_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_prefix);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
             }
-        }
-        public static void Value(string prefix, float v)
-        {
-            byte* native_prefix;
-            int prefix_byteCount = 0;
-            if (prefix != null)
+            else { native_format = null; }
+            fixed (float* native_v = &v)
             {
-                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
-                if (prefix_byteCount > Util.StackAllocationSizeLimit)
+                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_prefix = Util.Allocate(prefix_byteCount + 1);
+                    Util.Free(native_label);
                 }
-                else
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
-                    native_prefix = native_prefix_stackBytes;
+                    Util.Free(native_format);
                 }
-                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
-                native_prefix[native_prefix_offset] = 0;
-            }
-            else { native_prefix = null; }
-            byte* native_float_format = null;
-            ImGuiNative.igValueFloat(native_prefix, v, native_float_format);
-            if (prefix_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_prefix);
+                return ret != 0;
             }
         }
-        public static void Value(string prefix, float v, string float_format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderInt(ReadOnlySpan<char> label, Vector2 size, ref int v, int v_min, int v_max)
         {
-            byte* native_prefix;
-            int prefix_byteCount = 0;
-            if (prefix != null)
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
             {
-                prefix_byteCount = Encoding.UTF8.GetByteCount(prefix);
-                if (prefix_byteCount > Util.StackAllocationSizeLimit)
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_prefix = Util.Allocate(prefix_byteCount + 1);
+                    native_label = Util.Allocate(label_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_prefix_stackBytes = stackalloc byte[prefix_byteCount + 1];
-                    native_prefix = native_prefix_stackBytes;
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
                 }
-                int native_prefix_offset = Util.GetUtf8(prefix, native_prefix, prefix_byteCount);
-                native_prefix[native_prefix_offset] = 0;
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
             }
-            else { native_prefix = null; }
-            byte* native_float_format;
-            int float_format_byteCount = 0;
-            if (float_format != null)
-            {
-                float_format_byteCount = Encoding.UTF8.GetByteCount(float_format);
-                if (float_format_byteCount > Util.StackAllocationSizeLimit)
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
-                    native_float_format = Util.Allocate(float_format_byteCount + 1);
+                    native_format = Util.Allocate(format_byteCount + 1);
                 }
                 else
                 {
-                    byte* native_float_format_stackBytes = stackalloc byte[float_format_byteCount + 1];
-                    native_float_format = native_float_format_stackBytes;
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
                 }
-                int native_float_format_offset = Util.GetUtf8(float_format, native_float_format, float_format_byteCount);
-                native_float_format[native_float_format_offset] = 0;
-            }
-            else { native_float_format = null; }
-            ImGuiNative.igValueFloat(native_prefix, v, native_float_format);
-            if (prefix_byteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(native_prefix);
-            }
-            if (float_format_byteCount > Util.StackAllocationSizeLimit)
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                Util.Free(native_float_format);
+                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format, flags);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
             }
         }
-        public static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max)
+#endif
+        public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12726,7 +28126,7 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%.3f");
+                format_byteCount = Encoding.UTF8.GetByteCount("%d");
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -12736,12 +28136,12 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%.3f", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -12753,7 +28153,8 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
                 return ret != 0;
             }
         }
-        public static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderInt(ReadOnlySpan<char> label, Vector2 size, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12791,10 +28192,10 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            float power = 1.0f;
-            fixed (float* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -12806,7 +28207,8 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
                 return ret != 0;
             }
         }
-        public static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format, float power)
+#endif
+        public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12844,9 +28246,10 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            fixed (float* native_v = &v)
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            fixed (int* native_v = &v)
             {
-                byte ret = ImGuiNative.igVSliderFloat(native_label, size, native_v, v_min, v_max, native_format, power);
+                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -12858,7 +28261,8 @@ public static bool VSliderFloat(string label, Vector2 size, ref float v, float v
                 return ret != 0;
             }
         }
-        public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderInt(ReadOnlySpan<char> label, Vector2 size, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12880,7 +28284,9 @@ public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min,
             else { native_label = null; }
             byte* native_format;
             int format_byteCount = 0;
-                format_byteCount = Encoding.UTF8.GetByteCount("%d");
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
                 if (format_byteCount > Util.StackAllocationSizeLimit)
                 {
                     native_format = Util.Allocate(format_byteCount + 1);
@@ -12890,11 +28296,13 @@ public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min,
                     byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
                     native_format = native_format_stackBytes;
                 }
-                int native_format_offset = Util.GetUtf8("%d", native_format, format_byteCount);
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
                 native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
             fixed (int* native_v = &v)
             {
-                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -12906,7 +28314,8 @@ public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min,
                 return ret != 0;
             }
         }
-        public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format)
+#endif
+        public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12946,7 +28355,7 @@ public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min,
             else { native_format = null; }
             fixed (int* native_v = &v)
             {
-                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format);
+                byte ret = ImGuiNative.igVSliderInt(native_label, size, native_v, v_min, v_max, native_format, flags);
                 if (label_byteCount > Util.StackAllocationSizeLimit)
                 {
                     Util.Free(native_label);
@@ -12958,7 +28367,41 @@ public static bool VSliderInt(string label, Vector2 size, ref int v, int v_min,
                 return ret != 0;
             }
         }
-        public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr v, IntPtr v_min, IntPtr v_max)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderScalar(ReadOnlySpan<char> label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format = null;
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -12978,19 +28421,128 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
             byte* native_format = null;
-            float power = 1.0f;
-            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_v, native_v_min, native_v_max, native_format, power);
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderScalar(ReadOnlySpan<char> label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImGuiSliderFlags flags = (ImGuiSliderFlags)0;
+            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
             return ret != 0;
         }
-        public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr v, IntPtr v_min, IntPtr v_max, string format)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool VSliderScalar(ReadOnlySpan<char> label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -13010,9 +28562,9 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -13031,8 +28583,7 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            float power = 1.0f;
-            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_v, native_v_min, native_v_max, native_format, power);
+            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
@@ -13043,7 +28594,8 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
             }
             return ret != 0;
         }
-        public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr v, IntPtr v_min, IntPtr v_max, string format, float power)
+#endif
+        public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
         {
             byte* native_label;
             int label_byteCount = 0;
@@ -13063,9 +28615,9 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            void* native_v = (void*)v.ToPointer();
-            void* native_v_min = (void*)v_min.ToPointer();
-            void* native_v_max = (void*)v_max.ToPointer();
+            void* native_p_data = (void*)p_data.ToPointer();
+            void* native_p_min = (void*)p_min.ToPointer();
+            void* native_p_max = (void*)p_max.ToPointer();
             byte* native_format;
             int format_byteCount = 0;
             if (format != null)
@@ -13084,7 +28636,7 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
                 native_format[native_format_offset] = 0;
             }
             else { native_format = null; }
-            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_v, native_v_min, native_v_max, native_format, power);
+            byte ret = ImGuiNative.igVSliderScalar(native_label, size, data_type, native_p_data, native_p_min, native_p_max, native_format, flags);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
@@ -13095,5 +28647,10 @@ public static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_
             }
             return ret != 0;
         }
+        public static IntPtr* GetBuilderForFreeType()
+        {
+            IntPtr* ret = ImGuiNative.ImGuiFreeType_GetBuilderForFreeType();
+            return ret;
+        }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiBackendFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiBackendFlags.gen.cs
index 15914810..704dec42 100644
--- a/src/ImGui.NET/Generated/ImGuiBackendFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiBackendFlags.gen.cs
@@ -4,8 +4,12 @@ namespace ImGuiNET
     public enum ImGuiBackendFlags
     {
         None = 0,
-        HasGamepad = 1 << 0,
-        HasMouseCursors = 1 << 1,
-        HasSetMousePos = 1 << 2,
+        HasGamepad = 1,
+        HasMouseCursors = 2,
+        HasSetMousePos = 4,
+        RendererHasVtxOffset = 8,
+        PlatformHasViewports = 1024,
+        HasMouseHoveredViewport = 2048,
+        RendererHasViewports = 4096,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiButtonFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiButtonFlags.gen.cs
new file mode 100644
index 00000000..8443e2f7
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiButtonFlags.gen.cs
@@ -0,0 +1,13 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiButtonFlags
+    {
+        None = 0,
+        MouseButtonLeft = 1,
+        MouseButtonRight = 2,
+        MouseButtonMiddle = 4,
+        MouseButtonMask = 7,
+        EnableNav = 8,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiChildFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiChildFlags.gen.cs
new file mode 100644
index 00000000..3e27b4f5
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiChildFlags.gen.cs
@@ -0,0 +1,17 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiChildFlags
+    {
+        None = 0,
+        Borders = 1,
+        AlwaysUseWindowPadding = 2,
+        ResizeX = 4,
+        ResizeY = 8,
+        AutoResizeX = 16,
+        AutoResizeY = 32,
+        AlwaysAutoResize = 64,
+        FrameStyle = 128,
+        NavFlattened = 256,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiCol.gen.cs b/src/ImGui.NET/Generated/ImGuiCol.gen.cs
index 49a92d82..a9539b1b 100644
--- a/src/ImGui.NET/Generated/ImGuiCol.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiCol.gen.cs
@@ -35,21 +35,31 @@ public enum ImGuiCol
         ResizeGrip = 30,
         ResizeGripHovered = 31,
         ResizeGripActive = 32,
-        Tab = 33,
-        TabHovered = 34,
-        TabActive = 35,
-        TabUnfocused = 36,
-        TabUnfocusedActive = 37,
-        PlotLines = 38,
-        PlotLinesHovered = 39,
-        PlotHistogram = 40,
-        PlotHistogramHovered = 41,
-        TextSelectedBg = 42,
-        DragDropTarget = 43,
-        NavHighlight = 44,
-        NavWindowingHighlight = 45,
-        NavWindowingDimBg = 46,
-        ModalWindowDimBg = 47,
-        COUNT = 48,
+        TabHovered = 33,
+        Tab = 34,
+        TabSelected = 35,
+        TabSelectedOverline = 36,
+        TabDimmed = 37,
+        TabDimmedSelected = 38,
+        TabDimmedSelectedOverline = 39,
+        DockingPreview = 40,
+        DockingEmptyBg = 41,
+        PlotLines = 42,
+        PlotLinesHovered = 43,
+        PlotHistogram = 44,
+        PlotHistogramHovered = 45,
+        TableHeaderBg = 46,
+        TableBorderStrong = 47,
+        TableBorderLight = 48,
+        TableRowBg = 49,
+        TableRowBgAlt = 50,
+        TextLink = 51,
+        TextSelectedBg = 52,
+        DragDropTarget = 53,
+        NavCursor = 54,
+        NavWindowingHighlight = 55,
+        NavWindowingDimBg = 56,
+        ModalWindowDimBg = 57,
+        COUNT = 58,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiColorEditFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiColorEditFlags.gen.cs
index f87d6eaf..ede14577 100644
--- a/src/ImGui.NET/Generated/ImGuiColorEditFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiColorEditFlags.gen.cs
@@ -4,29 +4,33 @@ namespace ImGuiNET
     public enum ImGuiColorEditFlags
     {
         None = 0,
-        NoAlpha = 1 << 1,
-        NoPicker = 1 << 2,
-        NoOptions = 1 << 3,
-        NoSmallPreview = 1 << 4,
-        NoInputs = 1 << 5,
-        NoTooltip = 1 << 6,
-        NoLabel = 1 << 7,
-        NoSidePreview = 1 << 8,
-        NoDragDrop = 1 << 9,
-        AlphaBar = 1 << 16,
-        AlphaPreview = 1 << 17,
-        AlphaPreviewHalf = 1 << 18,
-        HDR = 1 << 19,
-        RGB = 1 << 20,
-        HSV = 1 << 21,
-        HEX = 1 << 22,
-        Uint8 = 1 << 23,
-        Float = 1 << 24,
-        PickerHueBar = 1 << 25,
-        PickerHueWheel = 1 << 26,
-        _InputsMask = RGB|HSV|HEX,
-        _DataTypeMask = Uint8|Float,
-        _PickerMask = PickerHueWheel|PickerHueBar,
-        _OptionsDefault = Uint8|RGB|PickerHueBar,
+        NoAlpha = 2,
+        NoPicker = 4,
+        NoOptions = 8,
+        NoSmallPreview = 16,
+        NoInputs = 32,
+        NoTooltip = 64,
+        NoLabel = 128,
+        NoSidePreview = 256,
+        NoDragDrop = 512,
+        NoBorder = 1024,
+        AlphaBar = 65536,
+        AlphaPreview = 131072,
+        AlphaPreviewHalf = 262144,
+        HDR = 524288,
+        DisplayRGB = 1048576,
+        DisplayHSV = 2097152,
+        DisplayHex = 4194304,
+        Uint8 = 8388608,
+        Float = 16777216,
+        PickerHueBar = 33554432,
+        PickerHueWheel = 67108864,
+        InputRGB = 134217728,
+        InputHSV = 268435456,
+        DefaultOptions = 177209344,
+        DisplayMask = 7340032,
+        DataTypeMask = 25165824,
+        PickerMask = 100663296,
+        InputMask = 402653184,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiComboFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiComboFlags.gen.cs
index 00227500..eec43092 100644
--- a/src/ImGui.NET/Generated/ImGuiComboFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiComboFlags.gen.cs
@@ -4,13 +4,14 @@ namespace ImGuiNET
     public enum ImGuiComboFlags
     {
         None = 0,
-        PopupAlignLeft = 1 << 0,
-        HeightSmall = 1 << 1,
-        HeightRegular = 1 << 2,
-        HeightLarge = 1 << 3,
-        HeightLargest = 1 << 4,
-        NoArrowButton = 1 << 5,
-        NoPreview = 1 << 6,
-        HeightMask = HeightSmall | HeightRegular | HeightLarge | HeightLargest,
+        PopupAlignLeft = 1,
+        HeightSmall = 2,
+        HeightRegular = 4,
+        HeightLarge = 8,
+        HeightLargest = 16,
+        NoArrowButton = 32,
+        NoPreview = 64,
+        WidthFitPreview = 128,
+        HeightMask = 30,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiCond.gen.cs b/src/ImGui.NET/Generated/ImGuiCond.gen.cs
index 917c0440..23a4cbbb 100644
--- a/src/ImGui.NET/Generated/ImGuiCond.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiCond.gen.cs
@@ -2,9 +2,10 @@ namespace ImGuiNET
 {
     public enum ImGuiCond
     {
-        Always = 1 << 0,
-        Once = 1 << 1,
-        FirstUseEver = 1 << 2,
-        Appearing = 1 << 3,
+        None = 0,
+        Always = 1,
+        Once = 2,
+        FirstUseEver = 4,
+        Appearing = 8,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiConfigFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiConfigFlags.gen.cs
index 4d0b6d28..3da8b7bf 100644
--- a/src/ImGui.NET/Generated/ImGuiConfigFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiConfigFlags.gen.cs
@@ -4,13 +4,16 @@ namespace ImGuiNET
     public enum ImGuiConfigFlags
     {
         None = 0,
-        NavEnableKeyboard = 1 << 0,
-        NavEnableGamepad = 1 << 1,
-        NavEnableSetMousePos = 1 << 2,
-        NavNoCaptureKeyboard = 1 << 3,
-        NoMouse = 1 << 4,
-        NoMouseCursorChange = 1 << 5,
-        IsSRGB = 1 << 20,
-        IsTouchScreen = 1 << 21,
+        NavEnableKeyboard = 1,
+        NavEnableGamepad = 2,
+        NoMouse = 16,
+        NoMouseCursorChange = 32,
+        NoKeyboard = 64,
+        DockingEnable = 128,
+        ViewportsEnable = 1024,
+        DpiEnableScaleViewports = 16384,
+        DpiEnableScaleFonts = 32768,
+        IsSRGB = 1048576,
+        IsTouchScreen = 2097152,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiDataType.gen.cs b/src/ImGui.NET/Generated/ImGuiDataType.gen.cs
index 57eb3782..d88dfc1d 100644
--- a/src/ImGui.NET/Generated/ImGuiDataType.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiDataType.gen.cs
@@ -2,12 +2,17 @@ namespace ImGuiNET
 {
     public enum ImGuiDataType
     {
-        S32 = 0,
-        U32 = 1,
-        S64 = 2,
-        U64 = 3,
-        Float = 4,
-        Double = 5,
-        COUNT = 6,
+        S8 = 0,
+        U8 = 1,
+        S16 = 2,
+        U16 = 3,
+        S32 = 4,
+        U32 = 5,
+        S64 = 6,
+        U64 = 7,
+        Float = 8,
+        Double = 9,
+        Bool = 10,
+        COUNT = 11,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiDockNodeFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiDockNodeFlags.gen.cs
new file mode 100644
index 00000000..9f8aff3d
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiDockNodeFlags.gen.cs
@@ -0,0 +1,15 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiDockNodeFlags
+    {
+        None = 0,
+        KeepAliveOnly = 1,
+        NoDockingOverCentralNode = 4,
+        PassthruCentralNode = 8,
+        NoDockingSplit = 16,
+        NoResize = 32,
+        AutoHideTabBar = 64,
+        NoUndocking = 128,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiDragDropFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiDragDropFlags.gen.cs
index 9e95b500..ef8c5657 100644
--- a/src/ImGui.NET/Generated/ImGuiDragDropFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiDragDropFlags.gen.cs
@@ -4,15 +4,17 @@ namespace ImGuiNET
     public enum ImGuiDragDropFlags
     {
         None = 0,
-        SourceNoPreviewTooltip = 1 << 0,
-        SourceNoDisableHover = 1 << 1,
-        SourceNoHoldToOpenOthers = 1 << 2,
-        SourceAllowNullID = 1 << 3,
-        SourceExtern = 1 << 4,
-        SourceAutoExpirePayload = 1 << 5,
-        AcceptBeforeDelivery = 1 << 10,
-        AcceptNoDrawDefaultRect = 1 << 11,
-        AcceptNoPreviewTooltip = 1 << 12,
-        AcceptPeekOnly = AcceptBeforeDelivery | AcceptNoDrawDefaultRect,
+        SourceNoPreviewTooltip = 1,
+        SourceNoDisableHover = 2,
+        SourceNoHoldToOpenOthers = 4,
+        SourceAllowNullID = 8,
+        SourceExtern = 16,
+        PayloadAutoExpire = 32,
+        PayloadNoCrossContext = 64,
+        PayloadNoCrossProcess = 128,
+        AcceptBeforeDelivery = 1024,
+        AcceptNoDrawDefaultRect = 2048,
+        AcceptNoPreviewTooltip = 4096,
+        AcceptPeekOnly = 3072,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiFocusedFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiFocusedFlags.gen.cs
index e9169c1c..249a42fb 100644
--- a/src/ImGui.NET/Generated/ImGuiFocusedFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiFocusedFlags.gen.cs
@@ -4,9 +4,11 @@ namespace ImGuiNET
     public enum ImGuiFocusedFlags
     {
         None = 0,
-        ChildWindows = 1 << 0,
-        RootWindow = 1 << 1,
-        AnyWindow = 1 << 2,
-        RootAndChildWindows = RootWindow | ChildWindows,
+        ChildWindows = 1,
+        RootWindow = 2,
+        AnyWindow = 4,
+        NoPopupHierarchy = 8,
+        DockHierarchy = 16,
+        RootAndChildWindows = 3,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiFreeTypeBuilderFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiFreeTypeBuilderFlags.gen.cs
new file mode 100644
index 00000000..ee6b10ea
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiFreeTypeBuilderFlags.gen.cs
@@ -0,0 +1,17 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiFreeTypeBuilderFlags
+    {
+        NoHinting = 1,
+        NoAutoHint = 2,
+        ForceAutoHint = 4,
+        LightHinting = 8,
+        MonoHinting = 16,
+        Bold = 32,
+        Oblique = 64,
+        Monochrome = 128,
+        LoadColor = 256,
+        Bitmap = 512,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiHoveredFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiHoveredFlags.gen.cs
index 5e5d5c23..fa1b7adf 100644
--- a/src/ImGui.NET/Generated/ImGuiHoveredFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiHoveredFlags.gen.cs
@@ -4,14 +4,25 @@ namespace ImGuiNET
     public enum ImGuiHoveredFlags
     {
         None = 0,
-        ChildWindows = 1 << 0,
-        RootWindow = 1 << 1,
-        AnyWindow = 1 << 2,
-        AllowWhenBlockedByPopup = 1 << 3,
-        AllowWhenBlockedByActiveItem = 1 << 5,
-        AllowWhenOverlapped = 1 << 6,
-        AllowWhenDisabled = 1 << 7,
-        RectOnly = AllowWhenBlockedByPopup | AllowWhenBlockedByActiveItem | AllowWhenOverlapped,
-        RootAndChildWindows = RootWindow | ChildWindows,
+        ChildWindows = 1,
+        RootWindow = 2,
+        AnyWindow = 4,
+        NoPopupHierarchy = 8,
+        DockHierarchy = 16,
+        AllowWhenBlockedByPopup = 32,
+        AllowWhenBlockedByActiveItem = 128,
+        AllowWhenOverlappedByItem = 256,
+        AllowWhenOverlappedByWindow = 512,
+        AllowWhenDisabled = 1024,
+        NoNavOverride = 2048,
+        AllowWhenOverlapped = 768,
+        RectOnly = 928,
+        RootAndChildWindows = 3,
+        ForTooltip = 4096,
+        Stationary = 8192,
+        DelayNone = 16384,
+        DelayShort = 32768,
+        DelayNormal = 65536,
+        NoSharedDelay = 131072,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiIO.gen.cs b/src/ImGui.NET/Generated/ImGuiIO.gen.cs
index 409b34b9..1b487a46 100644
--- a/src/ImGui.NET/Generated/ImGuiIO.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiIO.gen.cs
@@ -14,46 +14,58 @@ public unsafe partial struct ImGuiIO
         public float IniSavingRate;
         public byte* IniFilename;
         public byte* LogFilename;
-        public float MouseDoubleClickTime;
-        public float MouseDoubleClickMaxDist;
-        public float MouseDragThreshold;
-        public fixed int KeyMap[21];
-        public float KeyRepeatDelay;
-        public float KeyRepeatRate;
         public void* UserData;
         public ImFontAtlas* Fonts;
         public float FontGlobalScale;
         public byte FontAllowUserScaling;
         public ImFont* FontDefault;
         public Vector2 DisplayFramebufferScale;
-        public Vector2 DisplayVisibleMin;
-        public Vector2 DisplayVisibleMax;
+        public byte ConfigNavSwapGamepadButtons;
+        public byte ConfigNavMoveSetMousePos;
+        public byte ConfigNavCaptureKeyboard;
+        public byte ConfigNavEscapeClearFocusItem;
+        public byte ConfigNavEscapeClearFocusWindow;
+        public byte ConfigNavCursorVisibleAuto;
+        public byte ConfigNavCursorVisibleAlways;
+        public byte ConfigDockingNoSplit;
+        public byte ConfigDockingWithShift;
+        public byte ConfigDockingAlwaysTabBar;
+        public byte ConfigDockingTransparentPayload;
+        public byte ConfigViewportsNoAutoMerge;
+        public byte ConfigViewportsNoTaskBarIcon;
+        public byte ConfigViewportsNoDecoration;
+        public byte ConfigViewportsNoDefaultParent;
         public byte MouseDrawCursor;
         public byte ConfigMacOSXBehaviors;
+        public byte ConfigInputTrickleEventQueue;
         public byte ConfigInputTextCursorBlink;
+        public byte ConfigInputTextEnterKeepActive;
+        public byte ConfigDragClickToInputText;
         public byte ConfigWindowsResizeFromEdges;
         public byte ConfigWindowsMoveFromTitleBarOnly;
+        public byte ConfigWindowsCopyContentsWithCtrlC;
+        public byte ConfigScrollbarScrollByPage;
+        public float ConfigMemoryCompactTimer;
+        public float MouseDoubleClickTime;
+        public float MouseDoubleClickMaxDist;
+        public float MouseDragThreshold;
+        public float KeyRepeatDelay;
+        public float KeyRepeatRate;
+        public byte ConfigErrorRecovery;
+        public byte ConfigErrorRecoveryEnableAssert;
+        public byte ConfigErrorRecoveryEnableDebugLog;
+        public byte ConfigErrorRecoveryEnableTooltip;
+        public byte ConfigDebugIsDebuggerPresent;
+        public byte ConfigDebugHighlightIdConflicts;
+        public byte ConfigDebugBeginReturnValueOnce;
+        public byte ConfigDebugBeginReturnValueLoop;
+        public byte ConfigDebugIgnoreFocusLoss;
+        public byte ConfigDebugIniSettings;
         public byte* BackendPlatformName;
         public byte* BackendRendererName;
         public void* BackendPlatformUserData;
         public void* BackendRendererUserData;
         public void* BackendLanguageUserData;
-        public IntPtr GetClipboardTextFn;
-        public IntPtr SetClipboardTextFn;
-        public void* ClipboardUserData;
-        public IntPtr ImeSetInputScreenPosFn;
-        public void* ImeWindowHandle;
-        public void* RenderDrawListsFnUnused;
-        public Vector2 MousePos;
-        public fixed byte MouseDown[5];
-        public float MouseWheel;
-        public float MouseWheelH;
-        public byte KeyCtrl;
-        public byte KeyShift;
-        public byte KeyAlt;
-        public byte KeySuper;
-        public fixed byte KeysDown[512];
-        public fixed float NavInputs[21];
         public byte WantCaptureMouse;
         public byte WantCaptureKeyboard;
         public byte WantTextInput;
@@ -66,8 +78,174 @@ public unsafe partial struct ImGuiIO
         public int MetricsRenderIndices;
         public int MetricsRenderWindows;
         public int MetricsActiveWindows;
-        public int MetricsActiveAllocations;
         public Vector2 MouseDelta;
+        public IntPtr Ctx;
+        public Vector2 MousePos;
+        public fixed byte MouseDown[5];
+        public float MouseWheel;
+        public float MouseWheelH;
+        public ImGuiMouseSource MouseSource;
+        public uint MouseHoveredViewport;
+        public byte KeyCtrl;
+        public byte KeyShift;
+        public byte KeyAlt;
+        public byte KeySuper;
+        public ImGuiKey KeyMods;
+        public ImGuiKeyData KeysData_0;
+        public ImGuiKeyData KeysData_1;
+        public ImGuiKeyData KeysData_2;
+        public ImGuiKeyData KeysData_3;
+        public ImGuiKeyData KeysData_4;
+        public ImGuiKeyData KeysData_5;
+        public ImGuiKeyData KeysData_6;
+        public ImGuiKeyData KeysData_7;
+        public ImGuiKeyData KeysData_8;
+        public ImGuiKeyData KeysData_9;
+        public ImGuiKeyData KeysData_10;
+        public ImGuiKeyData KeysData_11;
+        public ImGuiKeyData KeysData_12;
+        public ImGuiKeyData KeysData_13;
+        public ImGuiKeyData KeysData_14;
+        public ImGuiKeyData KeysData_15;
+        public ImGuiKeyData KeysData_16;
+        public ImGuiKeyData KeysData_17;
+        public ImGuiKeyData KeysData_18;
+        public ImGuiKeyData KeysData_19;
+        public ImGuiKeyData KeysData_20;
+        public ImGuiKeyData KeysData_21;
+        public ImGuiKeyData KeysData_22;
+        public ImGuiKeyData KeysData_23;
+        public ImGuiKeyData KeysData_24;
+        public ImGuiKeyData KeysData_25;
+        public ImGuiKeyData KeysData_26;
+        public ImGuiKeyData KeysData_27;
+        public ImGuiKeyData KeysData_28;
+        public ImGuiKeyData KeysData_29;
+        public ImGuiKeyData KeysData_30;
+        public ImGuiKeyData KeysData_31;
+        public ImGuiKeyData KeysData_32;
+        public ImGuiKeyData KeysData_33;
+        public ImGuiKeyData KeysData_34;
+        public ImGuiKeyData KeysData_35;
+        public ImGuiKeyData KeysData_36;
+        public ImGuiKeyData KeysData_37;
+        public ImGuiKeyData KeysData_38;
+        public ImGuiKeyData KeysData_39;
+        public ImGuiKeyData KeysData_40;
+        public ImGuiKeyData KeysData_41;
+        public ImGuiKeyData KeysData_42;
+        public ImGuiKeyData KeysData_43;
+        public ImGuiKeyData KeysData_44;
+        public ImGuiKeyData KeysData_45;
+        public ImGuiKeyData KeysData_46;
+        public ImGuiKeyData KeysData_47;
+        public ImGuiKeyData KeysData_48;
+        public ImGuiKeyData KeysData_49;
+        public ImGuiKeyData KeysData_50;
+        public ImGuiKeyData KeysData_51;
+        public ImGuiKeyData KeysData_52;
+        public ImGuiKeyData KeysData_53;
+        public ImGuiKeyData KeysData_54;
+        public ImGuiKeyData KeysData_55;
+        public ImGuiKeyData KeysData_56;
+        public ImGuiKeyData KeysData_57;
+        public ImGuiKeyData KeysData_58;
+        public ImGuiKeyData KeysData_59;
+        public ImGuiKeyData KeysData_60;
+        public ImGuiKeyData KeysData_61;
+        public ImGuiKeyData KeysData_62;
+        public ImGuiKeyData KeysData_63;
+        public ImGuiKeyData KeysData_64;
+        public ImGuiKeyData KeysData_65;
+        public ImGuiKeyData KeysData_66;
+        public ImGuiKeyData KeysData_67;
+        public ImGuiKeyData KeysData_68;
+        public ImGuiKeyData KeysData_69;
+        public ImGuiKeyData KeysData_70;
+        public ImGuiKeyData KeysData_71;
+        public ImGuiKeyData KeysData_72;
+        public ImGuiKeyData KeysData_73;
+        public ImGuiKeyData KeysData_74;
+        public ImGuiKeyData KeysData_75;
+        public ImGuiKeyData KeysData_76;
+        public ImGuiKeyData KeysData_77;
+        public ImGuiKeyData KeysData_78;
+        public ImGuiKeyData KeysData_79;
+        public ImGuiKeyData KeysData_80;
+        public ImGuiKeyData KeysData_81;
+        public ImGuiKeyData KeysData_82;
+        public ImGuiKeyData KeysData_83;
+        public ImGuiKeyData KeysData_84;
+        public ImGuiKeyData KeysData_85;
+        public ImGuiKeyData KeysData_86;
+        public ImGuiKeyData KeysData_87;
+        public ImGuiKeyData KeysData_88;
+        public ImGuiKeyData KeysData_89;
+        public ImGuiKeyData KeysData_90;
+        public ImGuiKeyData KeysData_91;
+        public ImGuiKeyData KeysData_92;
+        public ImGuiKeyData KeysData_93;
+        public ImGuiKeyData KeysData_94;
+        public ImGuiKeyData KeysData_95;
+        public ImGuiKeyData KeysData_96;
+        public ImGuiKeyData KeysData_97;
+        public ImGuiKeyData KeysData_98;
+        public ImGuiKeyData KeysData_99;
+        public ImGuiKeyData KeysData_100;
+        public ImGuiKeyData KeysData_101;
+        public ImGuiKeyData KeysData_102;
+        public ImGuiKeyData KeysData_103;
+        public ImGuiKeyData KeysData_104;
+        public ImGuiKeyData KeysData_105;
+        public ImGuiKeyData KeysData_106;
+        public ImGuiKeyData KeysData_107;
+        public ImGuiKeyData KeysData_108;
+        public ImGuiKeyData KeysData_109;
+        public ImGuiKeyData KeysData_110;
+        public ImGuiKeyData KeysData_111;
+        public ImGuiKeyData KeysData_112;
+        public ImGuiKeyData KeysData_113;
+        public ImGuiKeyData KeysData_114;
+        public ImGuiKeyData KeysData_115;
+        public ImGuiKeyData KeysData_116;
+        public ImGuiKeyData KeysData_117;
+        public ImGuiKeyData KeysData_118;
+        public ImGuiKeyData KeysData_119;
+        public ImGuiKeyData KeysData_120;
+        public ImGuiKeyData KeysData_121;
+        public ImGuiKeyData KeysData_122;
+        public ImGuiKeyData KeysData_123;
+        public ImGuiKeyData KeysData_124;
+        public ImGuiKeyData KeysData_125;
+        public ImGuiKeyData KeysData_126;
+        public ImGuiKeyData KeysData_127;
+        public ImGuiKeyData KeysData_128;
+        public ImGuiKeyData KeysData_129;
+        public ImGuiKeyData KeysData_130;
+        public ImGuiKeyData KeysData_131;
+        public ImGuiKeyData KeysData_132;
+        public ImGuiKeyData KeysData_133;
+        public ImGuiKeyData KeysData_134;
+        public ImGuiKeyData KeysData_135;
+        public ImGuiKeyData KeysData_136;
+        public ImGuiKeyData KeysData_137;
+        public ImGuiKeyData KeysData_138;
+        public ImGuiKeyData KeysData_139;
+        public ImGuiKeyData KeysData_140;
+        public ImGuiKeyData KeysData_141;
+        public ImGuiKeyData KeysData_142;
+        public ImGuiKeyData KeysData_143;
+        public ImGuiKeyData KeysData_144;
+        public ImGuiKeyData KeysData_145;
+        public ImGuiKeyData KeysData_146;
+        public ImGuiKeyData KeysData_147;
+        public ImGuiKeyData KeysData_148;
+        public ImGuiKeyData KeysData_149;
+        public ImGuiKeyData KeysData_150;
+        public ImGuiKeyData KeysData_151;
+        public ImGuiKeyData KeysData_152;
+        public ImGuiKeyData KeysData_153;
+        public byte WantCaptureMouseUnlessPopupClose;
         public Vector2 MousePosPrev;
         public Vector2 MouseClickedPos_0;
         public Vector2 MouseClickedPos_1;
@@ -77,8 +255,13 @@ public unsafe partial struct ImGuiIO
         public fixed double MouseClickedTime[5];
         public fixed byte MouseClicked[5];
         public fixed byte MouseDoubleClicked[5];
+        public fixed ushort MouseClickedCount[5];
+        public fixed ushort MouseClickedLastCount[5];
         public fixed byte MouseReleased[5];
         public fixed byte MouseDownOwned[5];
+        public fixed byte MouseDownOwnedUnlessPopupClose[5];
+        public byte MouseWheelRequestAxisSwap;
+        public byte MouseCtrlLeftAsRightClick;
         public fixed float MouseDownDuration[5];
         public fixed float MouseDownDurationPrev[5];
         public Vector2 MouseDragMaxDistanceAbs_0;
@@ -87,10 +270,10 @@ public unsafe partial struct ImGuiIO
         public Vector2 MouseDragMaxDistanceAbs_3;
         public Vector2 MouseDragMaxDistanceAbs_4;
         public fixed float MouseDragMaxDistanceSqr[5];
-        public fixed float KeysDownDuration[512];
-        public fixed float KeysDownDurationPrev[512];
-        public fixed float NavInputsDownDuration[21];
-        public fixed float NavInputsDownDurationPrev[21];
+        public float PenPressure;
+        public byte AppFocusLost;
+        public byte AppAcceptingEvents;
+        public ushort InputQueueSurrogate;
         public ImVector InputQueueCharacters;
     }
     public unsafe partial struct ImGuiIOPtr
@@ -108,46 +291,58 @@ public unsafe partial struct ImGuiIOPtr
         public ref float IniSavingRate => ref Unsafe.AsRef<float>(&NativePtr->IniSavingRate);
         public NullTerminatedString IniFilename => new NullTerminatedString(NativePtr->IniFilename);
         public NullTerminatedString LogFilename => new NullTerminatedString(NativePtr->LogFilename);
-        public ref float MouseDoubleClickTime => ref Unsafe.AsRef<float>(&NativePtr->MouseDoubleClickTime);
-        public ref float MouseDoubleClickMaxDist => ref Unsafe.AsRef<float>(&NativePtr->MouseDoubleClickMaxDist);
-        public ref float MouseDragThreshold => ref Unsafe.AsRef<float>(&NativePtr->MouseDragThreshold);
-        public RangeAccessor<int> KeyMap => new RangeAccessor<int>(NativePtr->KeyMap, 21);
-        public ref float KeyRepeatDelay => ref Unsafe.AsRef<float>(&NativePtr->KeyRepeatDelay);
-        public ref float KeyRepeatRate => ref Unsafe.AsRef<float>(&NativePtr->KeyRepeatRate);
         public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
         public ImFontAtlasPtr Fonts => new ImFontAtlasPtr(NativePtr->Fonts);
         public ref float FontGlobalScale => ref Unsafe.AsRef<float>(&NativePtr->FontGlobalScale);
         public ref bool FontAllowUserScaling => ref Unsafe.AsRef<bool>(&NativePtr->FontAllowUserScaling);
         public ImFontPtr FontDefault => new ImFontPtr(NativePtr->FontDefault);
         public ref Vector2 DisplayFramebufferScale => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayFramebufferScale);
-        public ref Vector2 DisplayVisibleMin => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayVisibleMin);
-        public ref Vector2 DisplayVisibleMax => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayVisibleMax);
+        public ref bool ConfigNavSwapGamepadButtons => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavSwapGamepadButtons);
+        public ref bool ConfigNavMoveSetMousePos => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavMoveSetMousePos);
+        public ref bool ConfigNavCaptureKeyboard => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavCaptureKeyboard);
+        public ref bool ConfigNavEscapeClearFocusItem => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavEscapeClearFocusItem);
+        public ref bool ConfigNavEscapeClearFocusWindow => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavEscapeClearFocusWindow);
+        public ref bool ConfigNavCursorVisibleAuto => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavCursorVisibleAuto);
+        public ref bool ConfigNavCursorVisibleAlways => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavCursorVisibleAlways);
+        public ref bool ConfigDockingNoSplit => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingNoSplit);
+        public ref bool ConfigDockingWithShift => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingWithShift);
+        public ref bool ConfigDockingAlwaysTabBar => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingAlwaysTabBar);
+        public ref bool ConfigDockingTransparentPayload => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingTransparentPayload);
+        public ref bool ConfigViewportsNoAutoMerge => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoAutoMerge);
+        public ref bool ConfigViewportsNoTaskBarIcon => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoTaskBarIcon);
+        public ref bool ConfigViewportsNoDecoration => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoDecoration);
+        public ref bool ConfigViewportsNoDefaultParent => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoDefaultParent);
         public ref bool MouseDrawCursor => ref Unsafe.AsRef<bool>(&NativePtr->MouseDrawCursor);
         public ref bool ConfigMacOSXBehaviors => ref Unsafe.AsRef<bool>(&NativePtr->ConfigMacOSXBehaviors);
+        public ref bool ConfigInputTrickleEventQueue => ref Unsafe.AsRef<bool>(&NativePtr->ConfigInputTrickleEventQueue);
         public ref bool ConfigInputTextCursorBlink => ref Unsafe.AsRef<bool>(&NativePtr->ConfigInputTextCursorBlink);
+        public ref bool ConfigInputTextEnterKeepActive => ref Unsafe.AsRef<bool>(&NativePtr->ConfigInputTextEnterKeepActive);
+        public ref bool ConfigDragClickToInputText => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDragClickToInputText);
         public ref bool ConfigWindowsResizeFromEdges => ref Unsafe.AsRef<bool>(&NativePtr->ConfigWindowsResizeFromEdges);
         public ref bool ConfigWindowsMoveFromTitleBarOnly => ref Unsafe.AsRef<bool>(&NativePtr->ConfigWindowsMoveFromTitleBarOnly);
+        public ref bool ConfigWindowsCopyContentsWithCtrlC => ref Unsafe.AsRef<bool>(&NativePtr->ConfigWindowsCopyContentsWithCtrlC);
+        public ref bool ConfigScrollbarScrollByPage => ref Unsafe.AsRef<bool>(&NativePtr->ConfigScrollbarScrollByPage);
+        public ref float ConfigMemoryCompactTimer => ref Unsafe.AsRef<float>(&NativePtr->ConfigMemoryCompactTimer);
+        public ref float MouseDoubleClickTime => ref Unsafe.AsRef<float>(&NativePtr->MouseDoubleClickTime);
+        public ref float MouseDoubleClickMaxDist => ref Unsafe.AsRef<float>(&NativePtr->MouseDoubleClickMaxDist);
+        public ref float MouseDragThreshold => ref Unsafe.AsRef<float>(&NativePtr->MouseDragThreshold);
+        public ref float KeyRepeatDelay => ref Unsafe.AsRef<float>(&NativePtr->KeyRepeatDelay);
+        public ref float KeyRepeatRate => ref Unsafe.AsRef<float>(&NativePtr->KeyRepeatRate);
+        public ref bool ConfigErrorRecovery => ref Unsafe.AsRef<bool>(&NativePtr->ConfigErrorRecovery);
+        public ref bool ConfigErrorRecoveryEnableAssert => ref Unsafe.AsRef<bool>(&NativePtr->ConfigErrorRecoveryEnableAssert);
+        public ref bool ConfigErrorRecoveryEnableDebugLog => ref Unsafe.AsRef<bool>(&NativePtr->ConfigErrorRecoveryEnableDebugLog);
+        public ref bool ConfigErrorRecoveryEnableTooltip => ref Unsafe.AsRef<bool>(&NativePtr->ConfigErrorRecoveryEnableTooltip);
+        public ref bool ConfigDebugIsDebuggerPresent => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugIsDebuggerPresent);
+        public ref bool ConfigDebugHighlightIdConflicts => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugHighlightIdConflicts);
+        public ref bool ConfigDebugBeginReturnValueOnce => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugBeginReturnValueOnce);
+        public ref bool ConfigDebugBeginReturnValueLoop => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugBeginReturnValueLoop);
+        public ref bool ConfigDebugIgnoreFocusLoss => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugIgnoreFocusLoss);
+        public ref bool ConfigDebugIniSettings => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugIniSettings);
         public NullTerminatedString BackendPlatformName => new NullTerminatedString(NativePtr->BackendPlatformName);
         public NullTerminatedString BackendRendererName => new NullTerminatedString(NativePtr->BackendRendererName);
         public IntPtr BackendPlatformUserData { get => (IntPtr)NativePtr->BackendPlatformUserData; set => NativePtr->BackendPlatformUserData = (void*)value; }
         public IntPtr BackendRendererUserData { get => (IntPtr)NativePtr->BackendRendererUserData; set => NativePtr->BackendRendererUserData = (void*)value; }
         public IntPtr BackendLanguageUserData { get => (IntPtr)NativePtr->BackendLanguageUserData; set => NativePtr->BackendLanguageUserData = (void*)value; }
-        public ref IntPtr GetClipboardTextFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->GetClipboardTextFn);
-        public ref IntPtr SetClipboardTextFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->SetClipboardTextFn);
-        public IntPtr ClipboardUserData { get => (IntPtr)NativePtr->ClipboardUserData; set => NativePtr->ClipboardUserData = (void*)value; }
-        public ref IntPtr ImeSetInputScreenPosFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ImeSetInputScreenPosFn);
-        public IntPtr ImeWindowHandle { get => (IntPtr)NativePtr->ImeWindowHandle; set => NativePtr->ImeWindowHandle = (void*)value; }
-        public IntPtr RenderDrawListsFnUnused { get => (IntPtr)NativePtr->RenderDrawListsFnUnused; set => NativePtr->RenderDrawListsFnUnused = (void*)value; }
-        public ref Vector2 MousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePos);
-        public RangeAccessor<bool> MouseDown => new RangeAccessor<bool>(NativePtr->MouseDown, 5);
-        public ref float MouseWheel => ref Unsafe.AsRef<float>(&NativePtr->MouseWheel);
-        public ref float MouseWheelH => ref Unsafe.AsRef<float>(&NativePtr->MouseWheelH);
-        public ref bool KeyCtrl => ref Unsafe.AsRef<bool>(&NativePtr->KeyCtrl);
-        public ref bool KeyShift => ref Unsafe.AsRef<bool>(&NativePtr->KeyShift);
-        public ref bool KeyAlt => ref Unsafe.AsRef<bool>(&NativePtr->KeyAlt);
-        public ref bool KeySuper => ref Unsafe.AsRef<bool>(&NativePtr->KeySuper);
-        public RangeAccessor<bool> KeysDown => new RangeAccessor<bool>(NativePtr->KeysDown, 512);
-        public RangeAccessor<float> NavInputs => new RangeAccessor<float>(NativePtr->NavInputs, 21);
         public ref bool WantCaptureMouse => ref Unsafe.AsRef<bool>(&NativePtr->WantCaptureMouse);
         public ref bool WantCaptureKeyboard => ref Unsafe.AsRef<bool>(&NativePtr->WantCaptureKeyboard);
         public ref bool WantTextInput => ref Unsafe.AsRef<bool>(&NativePtr->WantTextInput);
@@ -160,28 +355,79 @@ public unsafe partial struct ImGuiIOPtr
         public ref int MetricsRenderIndices => ref Unsafe.AsRef<int>(&NativePtr->MetricsRenderIndices);
         public ref int MetricsRenderWindows => ref Unsafe.AsRef<int>(&NativePtr->MetricsRenderWindows);
         public ref int MetricsActiveWindows => ref Unsafe.AsRef<int>(&NativePtr->MetricsActiveWindows);
-        public ref int MetricsActiveAllocations => ref Unsafe.AsRef<int>(&NativePtr->MetricsActiveAllocations);
         public ref Vector2 MouseDelta => ref Unsafe.AsRef<Vector2>(&NativePtr->MouseDelta);
+        public ref IntPtr Ctx => ref Unsafe.AsRef<IntPtr>(&NativePtr->Ctx);
+        public ref Vector2 MousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePos);
+        public RangeAccessor<bool> MouseDown => new RangeAccessor<bool>(NativePtr->MouseDown, 5);
+        public ref float MouseWheel => ref Unsafe.AsRef<float>(&NativePtr->MouseWheel);
+        public ref float MouseWheelH => ref Unsafe.AsRef<float>(&NativePtr->MouseWheelH);
+        public ref ImGuiMouseSource MouseSource => ref Unsafe.AsRef<ImGuiMouseSource>(&NativePtr->MouseSource);
+        public ref uint MouseHoveredViewport => ref Unsafe.AsRef<uint>(&NativePtr->MouseHoveredViewport);
+        public ref bool KeyCtrl => ref Unsafe.AsRef<bool>(&NativePtr->KeyCtrl);
+        public ref bool KeyShift => ref Unsafe.AsRef<bool>(&NativePtr->KeyShift);
+        public ref bool KeyAlt => ref Unsafe.AsRef<bool>(&NativePtr->KeyAlt);
+        public ref bool KeySuper => ref Unsafe.AsRef<bool>(&NativePtr->KeySuper);
+        public ref ImGuiKey KeyMods => ref Unsafe.AsRef<ImGuiKey>(&NativePtr->KeyMods);
+        public RangeAccessor<ImGuiKeyData> KeysData => new RangeAccessor<ImGuiKeyData>(&NativePtr->KeysData_0, 154);
+        public ref bool WantCaptureMouseUnlessPopupClose => ref Unsafe.AsRef<bool>(&NativePtr->WantCaptureMouseUnlessPopupClose);
         public ref Vector2 MousePosPrev => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePosPrev);
         public RangeAccessor<Vector2> MouseClickedPos => new RangeAccessor<Vector2>(&NativePtr->MouseClickedPos_0, 5);
         public RangeAccessor<double> MouseClickedTime => new RangeAccessor<double>(NativePtr->MouseClickedTime, 5);
         public RangeAccessor<bool> MouseClicked => new RangeAccessor<bool>(NativePtr->MouseClicked, 5);
         public RangeAccessor<bool> MouseDoubleClicked => new RangeAccessor<bool>(NativePtr->MouseDoubleClicked, 5);
+        public RangeAccessor<ushort> MouseClickedCount => new RangeAccessor<ushort>(NativePtr->MouseClickedCount, 5);
+        public RangeAccessor<ushort> MouseClickedLastCount => new RangeAccessor<ushort>(NativePtr->MouseClickedLastCount, 5);
         public RangeAccessor<bool> MouseReleased => new RangeAccessor<bool>(NativePtr->MouseReleased, 5);
         public RangeAccessor<bool> MouseDownOwned => new RangeAccessor<bool>(NativePtr->MouseDownOwned, 5);
+        public RangeAccessor<bool> MouseDownOwnedUnlessPopupClose => new RangeAccessor<bool>(NativePtr->MouseDownOwnedUnlessPopupClose, 5);
+        public ref bool MouseWheelRequestAxisSwap => ref Unsafe.AsRef<bool>(&NativePtr->MouseWheelRequestAxisSwap);
+        public ref bool MouseCtrlLeftAsRightClick => ref Unsafe.AsRef<bool>(&NativePtr->MouseCtrlLeftAsRightClick);
         public RangeAccessor<float> MouseDownDuration => new RangeAccessor<float>(NativePtr->MouseDownDuration, 5);
         public RangeAccessor<float> MouseDownDurationPrev => new RangeAccessor<float>(NativePtr->MouseDownDurationPrev, 5);
         public RangeAccessor<Vector2> MouseDragMaxDistanceAbs => new RangeAccessor<Vector2>(&NativePtr->MouseDragMaxDistanceAbs_0, 5);
         public RangeAccessor<float> MouseDragMaxDistanceSqr => new RangeAccessor<float>(NativePtr->MouseDragMaxDistanceSqr, 5);
-        public RangeAccessor<float> KeysDownDuration => new RangeAccessor<float>(NativePtr->KeysDownDuration, 512);
-        public RangeAccessor<float> KeysDownDurationPrev => new RangeAccessor<float>(NativePtr->KeysDownDurationPrev, 512);
-        public RangeAccessor<float> NavInputsDownDuration => new RangeAccessor<float>(NativePtr->NavInputsDownDuration, 21);
-        public RangeAccessor<float> NavInputsDownDurationPrev => new RangeAccessor<float>(NativePtr->NavInputsDownDurationPrev, 21);
+        public ref float PenPressure => ref Unsafe.AsRef<float>(&NativePtr->PenPressure);
+        public ref bool AppFocusLost => ref Unsafe.AsRef<bool>(&NativePtr->AppFocusLost);
+        public ref bool AppAcceptingEvents => ref Unsafe.AsRef<bool>(&NativePtr->AppAcceptingEvents);
+        public ref ushort InputQueueSurrogate => ref Unsafe.AsRef<ushort>(&NativePtr->InputQueueSurrogate);
         public ImVector<ushort> InputQueueCharacters => new ImVector<ushort>(NativePtr->InputQueueCharacters);
-        public void AddInputCharacter(ushort c)
+        public void AddFocusEvent(bool focused)
+        {
+            byte native_focused = focused ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiIO_AddFocusEvent((ImGuiIO*)(NativePtr), native_focused);
+        }
+        public void AddInputCharacter(uint c)
         {
-            ImGuiNative.ImGuiIO_AddInputCharacter(NativePtr, c);
+            ImGuiNative.ImGuiIO_AddInputCharacter((ImGuiIO*)(NativePtr), c);
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void AddInputCharactersUTF8(ReadOnlySpan<char> str)
+        {
+            byte* native_str;
+            int str_byteCount = 0;
+            if (str != null)
+            {
+                str_byteCount = Encoding.UTF8.GetByteCount(str);
+                if (str_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str = Util.Allocate(str_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_stackBytes = stackalloc byte[str_byteCount + 1];
+                    native_str = native_str_stackBytes;
+                }
+                int native_str_offset = Util.GetUtf8(str, native_str, str_byteCount);
+                native_str[native_str_offset] = 0;
+            }
+            else { native_str = null; }
+            ImGuiNative.ImGuiIO_AddInputCharactersUTF8((ImGuiIO*)(NativePtr), native_str);
+            if (str_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str);
+            }
+        }
+#endif
         public void AddInputCharactersUTF8(string str)
         {
             byte* native_str;
@@ -202,15 +448,76 @@ public void AddInputCharactersUTF8(string str)
                 native_str[native_str_offset] = 0;
             }
             else { native_str = null; }
-            ImGuiNative.ImGuiIO_AddInputCharactersUTF8(NativePtr, native_str);
+            ImGuiNative.ImGuiIO_AddInputCharactersUTF8((ImGuiIO*)(NativePtr), native_str);
             if (str_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_str);
             }
         }
-        public void ClearInputCharacters()
+        public void AddInputCharacterUTF16(ushort c)
+        {
+            ImGuiNative.ImGuiIO_AddInputCharacterUTF16((ImGuiIO*)(NativePtr), c);
+        }
+        public void AddKeyAnalogEvent(ImGuiKey key, bool down, float v)
+        {
+            byte native_down = down ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiIO_AddKeyAnalogEvent((ImGuiIO*)(NativePtr), key, native_down, v);
+        }
+        public void AddKeyEvent(ImGuiKey key, bool down)
+        {
+            byte native_down = down ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiIO_AddKeyEvent((ImGuiIO*)(NativePtr), key, native_down);
+        }
+        public void AddMouseButtonEvent(int button, bool down)
+        {
+            byte native_down = down ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiIO_AddMouseButtonEvent((ImGuiIO*)(NativePtr), button, native_down);
+        }
+        public void AddMousePosEvent(float x, float y)
+        {
+            ImGuiNative.ImGuiIO_AddMousePosEvent((ImGuiIO*)(NativePtr), x, y);
+        }
+        public void AddMouseSourceEvent(ImGuiMouseSource source)
+        {
+            ImGuiNative.ImGuiIO_AddMouseSourceEvent((ImGuiIO*)(NativePtr), source);
+        }
+        public void AddMouseViewportEvent(uint id)
+        {
+            ImGuiNative.ImGuiIO_AddMouseViewportEvent((ImGuiIO*)(NativePtr), id);
+        }
+        public void AddMouseWheelEvent(float wheel_x, float wheel_y)
+        {
+            ImGuiNative.ImGuiIO_AddMouseWheelEvent((ImGuiIO*)(NativePtr), wheel_x, wheel_y);
+        }
+        public void ClearEventsQueue()
+        {
+            ImGuiNative.ImGuiIO_ClearEventsQueue((ImGuiIO*)(NativePtr));
+        }
+        public void ClearInputKeys()
+        {
+            ImGuiNative.ImGuiIO_ClearInputKeys((ImGuiIO*)(NativePtr));
+        }
+        public void ClearInputMouse()
+        {
+            ImGuiNative.ImGuiIO_ClearInputMouse((ImGuiIO*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiIO_destroy((ImGuiIO*)(NativePtr));
+        }
+        public void SetAppAcceptingEvents(bool accepting_events)
+        {
+            byte native_accepting_events = accepting_events ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiIO_SetAppAcceptingEvents((ImGuiIO*)(NativePtr), native_accepting_events);
+        }
+        public void SetKeyEventNativeData(ImGuiKey key, int native_keycode, int native_scancode)
+        {
+            int native_legacy_index = -1;
+            ImGuiNative.ImGuiIO_SetKeyEventNativeData((ImGuiIO*)(NativePtr), key, native_keycode, native_scancode, native_legacy_index);
+        }
+        public void SetKeyEventNativeData(ImGuiKey key, int native_keycode, int native_scancode, int native_legacy_index)
         {
-            ImGuiNative.ImGuiIO_ClearInputCharacters(NativePtr);
+            ImGuiNative.ImGuiIO_SetKeyEventNativeData((ImGuiIO*)(NativePtr), key, native_keycode, native_scancode, native_legacy_index);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiInputFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiInputFlags.gen.cs
new file mode 100644
index 00000000..838e1bec
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiInputFlags.gen.cs
@@ -0,0 +1,18 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiInputFlags
+    {
+        None = 0,
+        Repeat = 1,
+        RouteActive = 1024,
+        RouteFocused = 2048,
+        RouteGlobal = 4096,
+        RouteAlways = 8192,
+        RouteOverFocused = 16384,
+        RouteOverActive = 32768,
+        RouteUnlessBgFocused = 65536,
+        RouteFromRootWindow = 131072,
+        Tooltip = 262144,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiInputTextCallbackData.gen.cs b/src/ImGui.NET/Generated/ImGuiInputTextCallbackData.gen.cs
index 5775c6a9..10bd0faf 100644
--- a/src/ImGui.NET/Generated/ImGuiInputTextCallbackData.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiInputTextCallbackData.gen.cs
@@ -7,6 +7,7 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImGuiInputTextCallbackData
     {
+        public IntPtr Ctx;
         public ImGuiInputTextFlags EventFlag;
         public ImGuiInputTextFlags Flags;
         public void* UserData;
@@ -28,6 +29,7 @@ public unsafe partial struct ImGuiInputTextCallbackDataPtr
         public static implicit operator ImGuiInputTextCallbackDataPtr(ImGuiInputTextCallbackData* nativePtr) => new ImGuiInputTextCallbackDataPtr(nativePtr);
         public static implicit operator ImGuiInputTextCallbackData* (ImGuiInputTextCallbackDataPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiInputTextCallbackDataPtr(IntPtr nativePtr) => new ImGuiInputTextCallbackDataPtr(nativePtr);
+        public ref IntPtr Ctx => ref Unsafe.AsRef<IntPtr>(&NativePtr->Ctx);
         public ref ImGuiInputTextFlags EventFlag => ref Unsafe.AsRef<ImGuiInputTextFlags>(&NativePtr->EventFlag);
         public ref ImGuiInputTextFlags Flags => ref Unsafe.AsRef<ImGuiInputTextFlags>(&NativePtr->Flags);
         public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
@@ -40,15 +42,51 @@ public unsafe partial struct ImGuiInputTextCallbackDataPtr
         public ref int CursorPos => ref Unsafe.AsRef<int>(&NativePtr->CursorPos);
         public ref int SelectionStart => ref Unsafe.AsRef<int>(&NativePtr->SelectionStart);
         public ref int SelectionEnd => ref Unsafe.AsRef<int>(&NativePtr->SelectionEnd);
+        public void ClearSelection()
+        {
+            ImGuiNative.ImGuiInputTextCallbackData_ClearSelection((ImGuiInputTextCallbackData*)(NativePtr));
+        }
         public void DeleteChars(int pos, int bytes_count)
         {
-            ImGuiNative.ImGuiInputTextCallbackData_DeleteChars(NativePtr, pos, bytes_count);
+            ImGuiNative.ImGuiInputTextCallbackData_DeleteChars((ImGuiInputTextCallbackData*)(NativePtr), pos, bytes_count);
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiInputTextCallbackData_destroy((ImGuiInputTextCallbackData*)(NativePtr));
         }
         public bool HasSelection()
         {
-            byte ret = ImGuiNative.ImGuiInputTextCallbackData_HasSelection(NativePtr);
+            byte ret = ImGuiNative.ImGuiInputTextCallbackData_HasSelection((ImGuiInputTextCallbackData*)(NativePtr));
             return ret != 0;
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void InsertChars(int pos, ReadOnlySpan<char> text)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImGuiNative.ImGuiInputTextCallbackData_InsertChars((ImGuiInputTextCallbackData*)(NativePtr), pos, native_text, native_text+text_byteCount);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#endif
         public void InsertChars(int pos, string text)
         {
             byte* native_text;
@@ -69,12 +107,15 @@ public void InsertChars(int pos, string text)
                 native_text[native_text_offset] = 0;
             }
             else { native_text = null; }
-            byte* native_text_end = null;
-            ImGuiNative.ImGuiInputTextCallbackData_InsertChars(NativePtr, pos, native_text, native_text_end);
+            ImGuiNative.ImGuiInputTextCallbackData_InsertChars((ImGuiInputTextCallbackData*)(NativePtr), pos, native_text, native_text+text_byteCount);
             if (text_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_text);
             }
         }
+        public void SelectAll()
+        {
+            ImGuiNative.ImGuiInputTextCallbackData_SelectAll((ImGuiInputTextCallbackData*)(NativePtr));
+        }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiInputTextFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiInputTextFlags.gen.cs
index e7efe527..22e350fb 100644
--- a/src/ImGui.NET/Generated/ImGuiInputTextFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiInputTextFlags.gen.cs
@@ -4,25 +4,29 @@ namespace ImGuiNET
     public enum ImGuiInputTextFlags
     {
         None = 0,
-        CharsDecimal = 1 << 0,
-        CharsHexadecimal = 1 << 1,
-        CharsUppercase = 1 << 2,
-        CharsNoBlank = 1 << 3,
-        AutoSelectAll = 1 << 4,
-        EnterReturnsTrue = 1 << 5,
-        CallbackCompletion = 1 << 6,
-        CallbackHistory = 1 << 7,
-        CallbackAlways = 1 << 8,
-        CallbackCharFilter = 1 << 9,
-        AllowTabInput = 1 << 10,
-        CtrlEnterForNewLine = 1 << 11,
-        NoHorizontalScroll = 1 << 12,
-        AlwaysInsertMode = 1 << 13,
-        ReadOnly = 1 << 14,
-        Password = 1 << 15,
-        NoUndoRedo = 1 << 16,
-        CharsScientific = 1 << 17,
-        CallbackResize = 1 << 18,
-        Multiline = 1 << 20,
+        CharsDecimal = 1,
+        CharsHexadecimal = 2,
+        CharsScientific = 4,
+        CharsUppercase = 8,
+        CharsNoBlank = 16,
+        AllowTabInput = 32,
+        EnterReturnsTrue = 64,
+        EscapeClearsAll = 128,
+        CtrlEnterForNewLine = 256,
+        ReadOnly = 512,
+        Password = 1024,
+        AlwaysOverwrite = 2048,
+        AutoSelectAll = 4096,
+        ParseEmptyRefVal = 8192,
+        DisplayEmptyRefVal = 16384,
+        NoHorizontalScroll = 32768,
+        NoUndoRedo = 65536,
+        ElideLeft = 131072,
+        CallbackCompletion = 262144,
+        CallbackHistory = 524288,
+        CallbackAlways = 1048576,
+        CallbackCharFilter = 2097152,
+        CallbackResize = 4194304,
+        CallbackEdit = 8388608,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiItemFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiItemFlags.gen.cs
new file mode 100644
index 00000000..8c8befd9
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiItemFlags.gen.cs
@@ -0,0 +1,14 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiItemFlags
+    {
+        None = 0,
+        NoTabStop = 1,
+        NoNav = 2,
+        NoNavDefaultFocus = 4,
+        ButtonRepeat = 8,
+        AutoClosePopups = 16,
+        AllowDuplicateId = 32,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiKey.gen.cs b/src/ImGui.NET/Generated/ImGuiKey.gen.cs
index a351bd43..51e69bbe 100644
--- a/src/ImGui.NET/Generated/ImGuiKey.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiKey.gen.cs
@@ -2,27 +2,169 @@ namespace ImGuiNET
 {
     public enum ImGuiKey
     {
-        Tab = 0,
-        LeftArrow = 1,
-        RightArrow = 2,
-        UpArrow = 3,
-        DownArrow = 4,
-        PageUp = 5,
-        PageDown = 6,
-        Home = 7,
-        End = 8,
-        Insert = 9,
-        Delete = 10,
-        Backspace = 11,
-        Space = 12,
-        Enter = 13,
-        Escape = 14,
-        A = 15,
-        C = 16,
-        V = 17,
-        X = 18,
-        Y = 19,
-        Z = 20,
-        COUNT = 21,
+        None = 0,
+        NamedKey_BEGIN = 512,
+        Tab = 512,
+        LeftArrow = 513,
+        RightArrow = 514,
+        UpArrow = 515,
+        DownArrow = 516,
+        PageUp = 517,
+        PageDown = 518,
+        Home = 519,
+        End = 520,
+        Insert = 521,
+        Delete = 522,
+        Backspace = 523,
+        Space = 524,
+        Enter = 525,
+        Escape = 526,
+        LeftCtrl = 527,
+        LeftShift = 528,
+        LeftAlt = 529,
+        LeftSuper = 530,
+        RightCtrl = 531,
+        RightShift = 532,
+        RightAlt = 533,
+        RightSuper = 534,
+        Menu = 535,
+        _0 = 536,
+        _1 = 537,
+        _2 = 538,
+        _3 = 539,
+        _4 = 540,
+        _5 = 541,
+        _6 = 542,
+        _7 = 543,
+        _8 = 544,
+        _9 = 545,
+        A = 546,
+        B = 547,
+        C = 548,
+        D = 549,
+        E = 550,
+        F = 551,
+        G = 552,
+        H = 553,
+        I = 554,
+        J = 555,
+        K = 556,
+        L = 557,
+        M = 558,
+        N = 559,
+        O = 560,
+        P = 561,
+        Q = 562,
+        R = 563,
+        S = 564,
+        T = 565,
+        U = 566,
+        V = 567,
+        W = 568,
+        X = 569,
+        Y = 570,
+        Z = 571,
+        F1 = 572,
+        F2 = 573,
+        F3 = 574,
+        F4 = 575,
+        F5 = 576,
+        F6 = 577,
+        F7 = 578,
+        F8 = 579,
+        F9 = 580,
+        F10 = 581,
+        F11 = 582,
+        F12 = 583,
+        F13 = 584,
+        F14 = 585,
+        F15 = 586,
+        F16 = 587,
+        F17 = 588,
+        F18 = 589,
+        F19 = 590,
+        F20 = 591,
+        F21 = 592,
+        F22 = 593,
+        F23 = 594,
+        F24 = 595,
+        Apostrophe = 596,
+        Comma = 597,
+        Minus = 598,
+        Period = 599,
+        Slash = 600,
+        Semicolon = 601,
+        Equal = 602,
+        LeftBracket = 603,
+        Backslash = 604,
+        RightBracket = 605,
+        GraveAccent = 606,
+        CapsLock = 607,
+        ScrollLock = 608,
+        NumLock = 609,
+        PrintScreen = 610,
+        Pause = 611,
+        Keypad0 = 612,
+        Keypad1 = 613,
+        Keypad2 = 614,
+        Keypad3 = 615,
+        Keypad4 = 616,
+        Keypad5 = 617,
+        Keypad6 = 618,
+        Keypad7 = 619,
+        Keypad8 = 620,
+        Keypad9 = 621,
+        KeypadDecimal = 622,
+        KeypadDivide = 623,
+        KeypadMultiply = 624,
+        KeypadSubtract = 625,
+        KeypadAdd = 626,
+        KeypadEnter = 627,
+        KeypadEqual = 628,
+        AppBack = 629,
+        AppForward = 630,
+        GamepadStart = 631,
+        GamepadBack = 632,
+        GamepadFaceLeft = 633,
+        GamepadFaceRight = 634,
+        GamepadFaceUp = 635,
+        GamepadFaceDown = 636,
+        GamepadDpadLeft = 637,
+        GamepadDpadRight = 638,
+        GamepadDpadUp = 639,
+        GamepadDpadDown = 640,
+        GamepadL1 = 641,
+        GamepadR1 = 642,
+        GamepadL2 = 643,
+        GamepadR2 = 644,
+        GamepadL3 = 645,
+        GamepadR3 = 646,
+        GamepadLStickLeft = 647,
+        GamepadLStickRight = 648,
+        GamepadLStickUp = 649,
+        GamepadLStickDown = 650,
+        GamepadRStickLeft = 651,
+        GamepadRStickRight = 652,
+        GamepadRStickUp = 653,
+        GamepadRStickDown = 654,
+        MouseLeft = 655,
+        MouseRight = 656,
+        MouseMiddle = 657,
+        MouseX1 = 658,
+        MouseX2 = 659,
+        MouseWheelX = 660,
+        MouseWheelY = 661,
+        ReservedForModCtrl = 662,
+        ReservedForModShift = 663,
+        ReservedForModAlt = 664,
+        ReservedForModSuper = 665,
+        NamedKey_END = 666,
+        ModNone = 0,
+        ModCtrl = 4096,
+        ModShift = 8192,
+        ModAlt = 16384,
+        ModSuper = 32768,
+        ModMask = 61440,
+        NamedKey_COUNT = 154,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiKeyData.gen.cs b/src/ImGui.NET/Generated/ImGuiKeyData.gen.cs
new file mode 100644
index 00000000..68ebbdce
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiKeyData.gen.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiKeyData
+    {
+        public byte Down;
+        public float DownDuration;
+        public float DownDurationPrev;
+        public float AnalogValue;
+    }
+    public unsafe partial struct ImGuiKeyDataPtr
+    {
+        public ImGuiKeyData* NativePtr { get; }
+        public ImGuiKeyDataPtr(ImGuiKeyData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiKeyDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiKeyData*)nativePtr;
+        public static implicit operator ImGuiKeyDataPtr(ImGuiKeyData* nativePtr) => new ImGuiKeyDataPtr(nativePtr);
+        public static implicit operator ImGuiKeyData* (ImGuiKeyDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiKeyDataPtr(IntPtr nativePtr) => new ImGuiKeyDataPtr(nativePtr);
+        public ref bool Down => ref Unsafe.AsRef<bool>(&NativePtr->Down);
+        public ref float DownDuration => ref Unsafe.AsRef<float>(&NativePtr->DownDuration);
+        public ref float DownDurationPrev => ref Unsafe.AsRef<float>(&NativePtr->DownDurationPrev);
+        public ref float AnalogValue => ref Unsafe.AsRef<float>(&NativePtr->AnalogValue);
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiListClipper.gen.cs b/src/ImGui.NET/Generated/ImGuiListClipper.gen.cs
index c9bf3538..4e672d25 100644
--- a/src/ImGui.NET/Generated/ImGuiListClipper.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiListClipper.gen.cs
@@ -7,12 +7,14 @@ namespace ImGuiNET
 {
     public unsafe partial struct ImGuiListClipper
     {
-        public float StartPosY;
-        public float ItemsHeight;
-        public int ItemsCount;
-        public int StepNo;
+        public IntPtr Ctx;
         public int DisplayStart;
         public int DisplayEnd;
+        public int ItemsCount;
+        public float ItemsHeight;
+        public float StartPosY;
+        public double StartSeekOffsetY;
+        public void* TempData;
     }
     public unsafe partial struct ImGuiListClipperPtr
     {
@@ -22,28 +24,42 @@ public unsafe partial struct ImGuiListClipperPtr
         public static implicit operator ImGuiListClipperPtr(ImGuiListClipper* nativePtr) => new ImGuiListClipperPtr(nativePtr);
         public static implicit operator ImGuiListClipper* (ImGuiListClipperPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiListClipperPtr(IntPtr nativePtr) => new ImGuiListClipperPtr(nativePtr);
-        public ref float StartPosY => ref Unsafe.AsRef<float>(&NativePtr->StartPosY);
-        public ref float ItemsHeight => ref Unsafe.AsRef<float>(&NativePtr->ItemsHeight);
-        public ref int ItemsCount => ref Unsafe.AsRef<int>(&NativePtr->ItemsCount);
-        public ref int StepNo => ref Unsafe.AsRef<int>(&NativePtr->StepNo);
+        public ref IntPtr Ctx => ref Unsafe.AsRef<IntPtr>(&NativePtr->Ctx);
         public ref int DisplayStart => ref Unsafe.AsRef<int>(&NativePtr->DisplayStart);
         public ref int DisplayEnd => ref Unsafe.AsRef<int>(&NativePtr->DisplayEnd);
+        public ref int ItemsCount => ref Unsafe.AsRef<int>(&NativePtr->ItemsCount);
+        public ref float ItemsHeight => ref Unsafe.AsRef<float>(&NativePtr->ItemsHeight);
+        public ref float StartPosY => ref Unsafe.AsRef<float>(&NativePtr->StartPosY);
+        public ref double StartSeekOffsetY => ref Unsafe.AsRef<double>(&NativePtr->StartSeekOffsetY);
+        public IntPtr TempData { get => (IntPtr)NativePtr->TempData; set => NativePtr->TempData = (void*)value; }
         public void Begin(int items_count)
         {
             float items_height = -1.0f;
-            ImGuiNative.ImGuiListClipper_Begin(NativePtr, items_count, items_height);
+            ImGuiNative.ImGuiListClipper_Begin((ImGuiListClipper*)(NativePtr), items_count, items_height);
         }
         public void Begin(int items_count, float items_height)
         {
-            ImGuiNative.ImGuiListClipper_Begin(NativePtr, items_count, items_height);
+            ImGuiNative.ImGuiListClipper_Begin((ImGuiListClipper*)(NativePtr), items_count, items_height);
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiListClipper_destroy((ImGuiListClipper*)(NativePtr));
         }
         public void End()
         {
-            ImGuiNative.ImGuiListClipper_End(NativePtr);
+            ImGuiNative.ImGuiListClipper_End((ImGuiListClipper*)(NativePtr));
+        }
+        public void IncludeItemByIndex(int item_index)
+        {
+            ImGuiNative.ImGuiListClipper_IncludeItemByIndex((ImGuiListClipper*)(NativePtr), item_index);
+        }
+        public void SeekCursorForItem(int item_index)
+        {
+            ImGuiNative.ImGuiListClipper_SeekCursorForItem((ImGuiListClipper*)(NativePtr), item_index);
         }
         public bool Step()
         {
-            byte ret = ImGuiNative.ImGuiListClipper_Step(NativePtr);
+            byte ret = ImGuiNative.ImGuiListClipper_Step((ImGuiListClipper*)(NativePtr));
             return ret != 0;
         }
     }
diff --git a/src/ImGui.NET/Generated/ImGuiMouseButton.gen.cs b/src/ImGui.NET/Generated/ImGuiMouseButton.gen.cs
new file mode 100644
index 00000000..96a3fd1b
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiMouseButton.gen.cs
@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    public enum ImGuiMouseButton
+    {
+        Left = 0,
+        Right = 1,
+        Middle = 2,
+        COUNT = 5,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiMouseCursor.gen.cs b/src/ImGui.NET/Generated/ImGuiMouseCursor.gen.cs
index 1f817c43..fcf21e10 100644
--- a/src/ImGui.NET/Generated/ImGuiMouseCursor.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiMouseCursor.gen.cs
@@ -11,6 +11,7 @@ public enum ImGuiMouseCursor
         ResizeNESW = 5,
         ResizeNWSE = 6,
         Hand = 7,
-        COUNT = 8,
+        NotAllowed = 8,
+        COUNT = 9,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiMouseSource.gen.cs b/src/ImGui.NET/Generated/ImGuiMouseSource.gen.cs
new file mode 100644
index 00000000..58877f3b
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiMouseSource.gen.cs
@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    public enum ImGuiMouseSource
+    {
+        Mouse = 0,
+        TouchScreen = 1,
+        Pen = 2,
+        COUNT = 3,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiMultiSelectFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiMultiSelectFlags.gen.cs
new file mode 100644
index 00000000..949ec4bf
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiMultiSelectFlags.gen.cs
@@ -0,0 +1,24 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiMultiSelectFlags
+    {
+        None = 0,
+        SingleSelect = 1,
+        NoSelectAll = 2,
+        NoRangeSelect = 4,
+        NoAutoSelect = 8,
+        NoAutoClear = 16,
+        NoAutoClearOnReselect = 32,
+        BoxSelect1d = 64,
+        BoxSelect2d = 128,
+        BoxSelectNoScroll = 256,
+        ClearOnEscape = 512,
+        ClearOnClickVoid = 1024,
+        ScopeWindow = 2048,
+        ScopeRect = 4096,
+        SelectOnClick = 8192,
+        SelectOnClickRelease = 16384,
+        NavWrapX = 65536,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiMultiSelectIO.gen.cs b/src/ImGui.NET/Generated/ImGuiMultiSelectIO.gen.cs
new file mode 100644
index 00000000..8c8439f4
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiMultiSelectIO.gen.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiMultiSelectIO
+    {
+        public ImVector Requests;
+        public long RangeSrcItem;
+        public long NavIdItem;
+        public byte NavIdSelected;
+        public byte RangeSrcReset;
+        public int ItemsCount;
+    }
+    public unsafe partial struct ImGuiMultiSelectIOPtr
+    {
+        public ImGuiMultiSelectIO* NativePtr { get; }
+        public ImGuiMultiSelectIOPtr(ImGuiMultiSelectIO* nativePtr) => NativePtr = nativePtr;
+        public ImGuiMultiSelectIOPtr(IntPtr nativePtr) => NativePtr = (ImGuiMultiSelectIO*)nativePtr;
+        public static implicit operator ImGuiMultiSelectIOPtr(ImGuiMultiSelectIO* nativePtr) => new ImGuiMultiSelectIOPtr(nativePtr);
+        public static implicit operator ImGuiMultiSelectIO* (ImGuiMultiSelectIOPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiMultiSelectIOPtr(IntPtr nativePtr) => new ImGuiMultiSelectIOPtr(nativePtr);
+        public ImPtrVector<ImGuiSelectionRequestPtr> Requests => new ImPtrVector<ImGuiSelectionRequestPtr>(NativePtr->Requests, Unsafe.SizeOf<ImGuiSelectionRequest>());
+        public ref long RangeSrcItem => ref Unsafe.AsRef<long>(&NativePtr->RangeSrcItem);
+        public ref long NavIdItem => ref Unsafe.AsRef<long>(&NativePtr->NavIdItem);
+        public ref bool NavIdSelected => ref Unsafe.AsRef<bool>(&NativePtr->NavIdSelected);
+        public ref bool RangeSrcReset => ref Unsafe.AsRef<bool>(&NativePtr->RangeSrcReset);
+        public ref int ItemsCount => ref Unsafe.AsRef<int>(&NativePtr->ItemsCount);
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiNative.gen.cs b/src/ImGui.NET/Generated/ImGuiNative.gen.cs
index b9112052..95347fc4 100644
--- a/src/ImGui.NET/Generated/ImGuiNative.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiNative.gen.cs
@@ -6,10 +6,6 @@ namespace ImGuiNET
 {
     public static unsafe partial class ImGuiNative
     {
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CustomRect_CustomRect();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte CustomRect_IsPacked(CustomRect* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImGuiPayload* igAcceptDragDropPayload(byte* type, ImGuiDragDropFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -19,33 +15,39 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBegin(byte* name, byte* p_open, ImGuiWindowFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igBeginChild(byte* str_id, Vector2 size, byte border, ImGuiWindowFlags flags);
+        public static extern byte igBeginChild_Str(byte* str_id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igBeginChildID(uint id, Vector2 size, byte border, ImGuiWindowFlags flags);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igBeginChildFrame(uint id, Vector2 size, ImGuiWindowFlags flags);
+        public static extern byte igBeginChild_ID(uint id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginCombo(byte* label, byte* preview_value, ImGuiComboFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igBeginDisabled(byte disabled);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginDragDropSource(ImGuiDragDropFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginDragDropTarget();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igBeginGroup();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igBeginItemTooltip();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igBeginListBox(byte* label, Vector2 size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginMainMenuBar();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginMenu(byte* label, byte enabled);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginMenuBar();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiMultiSelectIO* igBeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size, int items_count);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginPopup(byte* str_id, ImGuiWindowFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igBeginPopupContextItem(byte* str_id, int mouse_button);
+        public static extern byte igBeginPopupContextItem(byte* str_id, ImGuiPopupFlags popup_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igBeginPopupContextVoid(byte* str_id, int mouse_button);
+        public static extern byte igBeginPopupContextVoid(byte* str_id, ImGuiPopupFlags popup_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igBeginPopupContextWindow(byte* str_id, int mouse_button, byte also_over_items);
+        public static extern byte igBeginPopupContextWindow(byte* str_id, ImGuiPopupFlags popup_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginPopupModal(byte* name, byte* p_open, ImGuiWindowFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -53,7 +55,9 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igBeginTabItem(byte* label, byte* p_open, ImGuiTabItemFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igBeginTooltip();
+        public static extern byte igBeginTable(byte* str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size, float inner_width);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igBeginTooltip();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igBullet();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -63,23 +67,19 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igCalcItemWidth();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igCalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igCalcTextSize_nonUDT2")]
-        public static extern Vector2 igCalcTextSize(byte* text, byte* text_end, byte hide_text_after_double_hash, float wrap_width);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igCaptureKeyboardFromApp(byte want_capture_keyboard_value);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igCaptureMouseFromApp(byte want_capture_mouse_value);
+        public static extern void igCalcTextSize(Vector2* pOut, byte* text, byte* text_end, byte hide_text_after_double_hash, float wrap_width);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igCheckbox(byte* label, byte* v);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igCheckboxFlags(byte* label, uint* flags, uint flags_value);
+        public static extern byte igCheckboxFlags_IntPtr(byte* label, int* flags, int flags_value);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igCheckboxFlags_UintPtr(byte* label, uint* flags, uint flags_value);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igCloseCurrentPopup();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igCollapsingHeader(byte* label, ImGuiTreeNodeFlags flags);
+        public static extern byte igCollapsingHeader_TreeNodeFlags(byte* label, ImGuiTreeNodeFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igCollapsingHeaderBoolPtr(byte* label, byte* p_open, ImGuiTreeNodeFlags flags);
+        public static extern byte igCollapsingHeader_BoolPtr(byte* label, byte* p_visible, ImGuiTreeNodeFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igColorButton(byte* desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -88,8 +88,8 @@ public static unsafe partial class ImGuiNative
         public static extern void igColorConvertHSVtoRGB(float h, float s, float v, float* out_r, float* out_g, float* out_b);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igColorConvertRGBtoHSV(float r, float g, float b, float* out_h, float* out_s, float* out_v);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igColorConvertU32ToFloat4_nonUDT2")]
-        public static extern Vector4 igColorConvertU32ToFloat4(uint @in);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igColorConvertU32ToFloat4(Vector4* pOut, uint @in);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igColorEdit3(byte* label, Vector3* col, ImGuiColorEditFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -99,41 +99,55 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igColorPicker4(byte* label, Vector4* col, ImGuiColorEditFlags flags, float* ref_col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igColumns(int count, byte* id, byte border);
+        public static extern void igColumns(int count, byte* id, byte borders);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igCombo(byte* label, int* current_item, byte** items, int items_count, int popup_max_height_in_items);
+        public static extern byte igCombo_Str_arr(byte* label, int* current_item, byte** items, int items_count, int popup_max_height_in_items);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igComboStr(byte* label, int* current_item, byte* items_separated_by_zeros, int popup_max_height_in_items);
+        public static extern byte igCombo_Str(byte* label, int* current_item, byte* items_separated_by_zeros, int popup_max_height_in_items);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr igCreateContext(ImFontAtlas* shared_font_atlas);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDebugCheckVersionAndDataLayout(byte* version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert);
+        public static extern byte igDebugCheckVersionAndDataLayout(byte* version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert, uint sz_drawidx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igDebugFlashStyleColor(ImGuiCol idx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igDebugLog(byte* fmt);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igDebugStartItemPicker();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igDebugTextEncoding(byte* text);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igDestroyContext(IntPtr ctx);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragFloat(byte* label, float* v, float v_speed, float v_min, float v_max, byte* format, float power);
+        public static extern void igDestroyPlatformWindows();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern uint igDockSpace(uint dockspace_id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClass* window_class);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern uint igDockSpaceOverViewport(uint dockspace_id, ImGuiViewport* viewport, ImGuiDockNodeFlags flags, ImGuiWindowClass* window_class);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragFloat2(byte* label, Vector2* v, float v_speed, float v_min, float v_max, byte* format, float power);
+        public static extern byte igDragFloat(byte* label, float* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragFloat3(byte* label, Vector3* v, float v_speed, float v_min, float v_max, byte* format, float power);
+        public static extern byte igDragFloat2(byte* label, Vector2* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragFloat4(byte* label, Vector4* v, float v_speed, float v_min, float v_max, byte* format, float power);
+        public static extern byte igDragFloat3(byte* label, Vector3* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragFloatRange2(byte* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, byte* format, byte* format_max, float power);
+        public static extern byte igDragFloat4(byte* label, Vector4* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragInt(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format);
+        public static extern byte igDragFloatRange2(byte* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, byte* format, byte* format_max, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragInt2(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format);
+        public static extern byte igDragInt(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragInt3(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format);
+        public static extern byte igDragInt2(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragInt4(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format);
+        public static extern byte igDragInt3(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragIntRange2(byte* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, byte* format, byte* format_max);
+        public static extern byte igDragInt4(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragScalar(byte* label, ImGuiDataType data_type, void* v, float v_speed, void* v_min, void* v_max, byte* format, float power);
+        public static extern byte igDragIntRange2(byte* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, byte* format, byte* format_max, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igDragScalarN(byte* label, ImGuiDataType data_type, void* v, int components, float v_speed, void* v_min, void* v_max, byte* format, float power);
+        public static extern byte igDragScalar(byte* label, ImGuiDataType data_type, void* p_data, float v_speed, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igDragScalarN(byte* label, ImGuiDataType data_type, void* p_data, int components, float v_speed, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igDummy(Vector2 size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -141,10 +155,10 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndChild();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igEndChildFrame();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndCombo();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igEndDisabled();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndDragDropSource();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndDragDropTarget();
@@ -153,27 +167,41 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndGroup();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igEndListBox();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndMainMenuBar();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndMenu();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndMenuBar();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiMultiSelectIO* igEndMultiSelect();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndPopup();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndTabBar();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndTabItem();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igEndTable();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igEndTooltip();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiViewport* igFindViewportByID(uint id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiViewport* igFindViewportByPlatformHandle(void* platform_handle);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetAllocatorFunctions(IntPtr* p_alloc_func, IntPtr* p_free_func, void** p_user_data);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawList* igGetBackgroundDrawList(ImGuiViewport* viewport);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte* igGetClipboardText();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint igGetColorU32(ImGuiCol idx, float alpha_mul);
+        public static extern uint igGetColorU32_Col(ImGuiCol idx, float alpha_mul);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint igGetColorU32Vec4(Vector4 col);
+        public static extern uint igGetColorU32_Vec4(Vector4 col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint igGetColorU32U32(uint col);
+        public static extern uint igGetColorU32_U32(uint col, float alpha_mul);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern int igGetColumnIndex();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -182,24 +210,20 @@ public static unsafe partial class ImGuiNative
         public static extern int igGetColumnsCount();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetColumnWidth(int column_index);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetContentRegionAvail_nonUDT2")]
-        public static extern Vector2 igGetContentRegionAvail();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern float igGetContentRegionAvailWidth();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetContentRegionMax_nonUDT2")]
-        public static extern Vector2 igGetContentRegionMax();
+        public static extern void igGetContentRegionAvail(Vector2* pOut);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr igGetCurrentContext();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetCursorPos_nonUDT2")]
-        public static extern Vector2 igGetCursorPos();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetCursorPos(Vector2* pOut);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetCursorPosX();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetCursorPosY();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetCursorScreenPos_nonUDT2")]
-        public static extern Vector2 igGetCursorScreenPos();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetCursorStartPos_nonUDT2")]
-        public static extern Vector2 igGetCursorStartPos();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetCursorScreenPos(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetCursorStartPos(Vector2* pOut);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImGuiPayload* igGetDragDropPayload();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -210,8 +234,10 @@ public static unsafe partial class ImGuiNative
         public static extern ImFont* igGetFont();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetFontSize();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetFontTexUvWhitePixel_nonUDT2")]
-        public static extern Vector2 igGetFontTexUvWhitePixel();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetFontTexUvWhitePixel(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern int igGetFrameCount();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -219,33 +245,41 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetFrameHeightWithSpacing();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint igGetIDStr(byte* str_id);
+        public static extern uint igGetID_Str(byte* str_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern uint igGetID_StrStr(byte* str_id_begin, byte* str_id_end);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint igGetIDRange(byte* str_id_begin, byte* str_id_end);
+        public static extern uint igGetID_Ptr(void* ptr_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint igGetIDPtr(void* ptr_id);
+        public static extern uint igGetID_Int(int int_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImGuiIO* igGetIO();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetItemRectMax_nonUDT2")]
-        public static extern Vector2 igGetItemRectMax();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetItemRectMin_nonUDT2")]
-        public static extern Vector2 igGetItemRectMin();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetItemRectSize_nonUDT2")]
-        public static extern Vector2 igGetItemRectSize();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int igGetKeyIndex(ImGuiKey imgui_key);
+        public static extern uint igGetItemID();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int igGetKeyPressedAmount(int key_index, float repeat_delay, float rate);
+        public static extern void igGetItemRectMax(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetItemRectMin(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetItemRectSize(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* igGetKeyName(ImGuiKey key);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int igGetKeyPressedAmount(ImGuiKey key, float repeat_delay, float rate);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiViewport* igGetMainViewport();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int igGetMouseClickedCount(ImGuiMouseButton button);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImGuiMouseCursor igGetMouseCursor();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetMouseDragDelta_nonUDT2")]
-        public static extern Vector2 igGetMouseDragDelta(int button, float lock_threshold);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetMousePos_nonUDT2")]
-        public static extern Vector2 igGetMousePos();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetMousePosOnOpeningCurrentPopup_nonUDT2")]
-        public static extern Vector2 igGetMousePosOnOpeningCurrentPopup();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern ImDrawList* igGetOverlayDrawList();
+        public static extern void igGetMouseDragDelta(Vector2* pOut, ImGuiMouseButton button, float lock_threshold);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetMousePos(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetMousePosOnOpeningCurrentPopup(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiPlatformIO* igGetPlatformIO();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetScrollMaxX();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -272,26 +306,26 @@ public static unsafe partial class ImGuiNative
         public static extern float igGetTreeNodeToLabelSpacing();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte* igGetVersion();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetWindowContentRegionMax_nonUDT2")]
-        public static extern Vector2 igGetWindowContentRegionMax();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetWindowContentRegionMin_nonUDT2")]
-        public static extern Vector2 igGetWindowContentRegionMin();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern float igGetWindowContentRegionWidth();
+        public static extern uint igGetWindowDockID();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern float igGetWindowDpiScale();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImDrawList* igGetWindowDrawList();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetWindowHeight();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetWindowPos_nonUDT2")]
-        public static extern Vector2 igGetWindowPos();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "igGetWindowSize_nonUDT2")]
-        public static extern Vector2 igGetWindowSize();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetWindowPos(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igGetWindowSize(Vector2* pOut);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiViewport* igGetWindowViewport();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern float igGetWindowWidth();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igImage(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col);
+        public static extern void igImage(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igImageButton(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, int frame_padding, Vector4 bg_col, Vector4 tint_col);
+        public static extern byte igImageButton(byte* str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igIndent(float indent_w);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -313,15 +347,17 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igInputInt4(byte* label, int* v, ImGuiInputTextFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igInputScalar(byte* label, ImGuiDataType data_type, void* v, void* step, void* step_fast, byte* format, ImGuiInputTextFlags flags);
+        public static extern byte igInputScalar(byte* label, ImGuiDataType data_type, void* p_data, void* p_step, void* p_step_fast, byte* format, ImGuiInputTextFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igInputScalarN(byte* label, ImGuiDataType data_type, void* v, int components, void* step, void* step_fast, byte* format, ImGuiInputTextFlags flags);
+        public static extern byte igInputScalarN(byte* label, ImGuiDataType data_type, void* p_data, int components, void* p_step, void* p_step_fast, byte* format, ImGuiInputTextFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igInputText(byte* label, byte* buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igInputTextMultiline(byte* label, byte* buf, uint buf_size, Vector2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igInvisibleButton(byte* str_id, Vector2 size);
+        public static extern byte igInputTextWithHint(byte* label, byte* hint, byte* buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igInvisibleButton(byte* str_id, Vector2 size, ImGuiButtonFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsAnyItemActive();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -331,9 +367,11 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsAnyMouseDown();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igIsItemActivated();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsItemActive();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsItemClicked(int mouse_button);
+        public static extern byte igIsItemClicked(ImGuiMouseButton mouse_button);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsItemDeactivated();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -345,51 +383,53 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsItemHovered(ImGuiHoveredFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igIsItemToggledOpen();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igIsItemToggledSelection();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsItemVisible();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsKeyDown(int user_key_index);
+        public static extern byte igIsKeyChordPressed_Nil(ImGuiKey key_chord);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsKeyPressed(int user_key_index, byte repeat);
+        public static extern byte igIsKeyDown_Nil(ImGuiKey key);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsKeyReleased(int user_key_index);
+        public static extern byte igIsKeyPressed_Bool(ImGuiKey key, byte repeat);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsMouseClicked(int button, byte repeat);
+        public static extern byte igIsKeyReleased_Nil(ImGuiKey key);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsMouseDoubleClicked(int button);
+        public static extern byte igIsMouseClicked_Bool(ImGuiMouseButton button, byte repeat);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsMouseDown(int button);
+        public static extern byte igIsMouseDoubleClicked_Nil(ImGuiMouseButton button);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsMouseDragging(int button, float lock_threshold);
+        public static extern byte igIsMouseDown_Nil(ImGuiMouseButton button);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igIsMouseDragging(ImGuiMouseButton button, float lock_threshold);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsMouseHoveringRect(Vector2 r_min, Vector2 r_max, byte clip);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsMousePosValid(Vector2* mouse_pos);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsMouseReleased(int button);
+        public static extern byte igIsMouseReleased_Nil(ImGuiMouseButton button);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsPopupOpen(byte* str_id);
+        public static extern byte igIsPopupOpen_Str(byte* str_id, ImGuiPopupFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsRectVisible(Vector2 size);
+        public static extern byte igIsRectVisible_Nil(Vector2 size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igIsRectVisibleVec2(Vector2 rect_min, Vector2 rect_max);
+        public static extern byte igIsRectVisible_Vec2(Vector2 rect_min, Vector2 rect_max);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsWindowAppearing();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsWindowCollapsed();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igIsWindowDocked();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsWindowFocused(ImGuiFocusedFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igIsWindowHovered(ImGuiHoveredFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igLabelText(byte* label, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igListBoxStr_arr(byte* label, int* current_item, byte** items, int items_count, int height_in_items);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igListBoxFooter();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igListBoxHeaderVec2(byte* label, Vector2 size);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igListBoxHeaderInt(byte* label, int items_count, int height_in_items);
+        public static extern byte igListBox_Str_arr(byte* label, int* current_item, byte** items, int items_count, int height_in_items);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igLoadIniSettingsFromDisk(byte* ini_filename);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -401,19 +441,19 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igLogText(byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igLogToClipboard(int max_depth);
+        public static extern void igLogToClipboard(int auto_open_depth);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igLogToFile(int max_depth, byte* filename);
+        public static extern void igLogToFile(int auto_open_depth, byte* filename);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igLogToTTY(int max_depth);
+        public static extern void igLogToTTY(int auto_open_depth);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void* igMemAlloc(uint size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igMemFree(void* ptr);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igMenuItemBool(byte* label, byte* shortcut, byte selected, byte enabled);
+        public static extern byte igMenuItem_Bool(byte* label, byte* shortcut, byte selected, byte enabled);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igMenuItemBoolPtr(byte* label, byte* shortcut, byte* p_selected, byte enabled);
+        public static extern byte igMenuItem_BoolPtr(byte* label, byte* shortcut, byte* p_selected, byte enabled);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igNewFrame();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -421,17 +461,15 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igNextColumn();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igOpenPopup(byte* str_id);
+        public static extern void igOpenPopup_Str(byte* str_id, ImGuiPopupFlags popup_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igOpenPopupOnItemClick(byte* str_id, int mouse_button);
+        public static extern void igOpenPopup_ID(uint id, ImGuiPopupFlags popup_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPlotHistogramFloatPtr(byte* label, float* values, int values_count, int values_offset, byte* overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride);
+        public static extern void igOpenPopupOnItemClick(byte* str_id, ImGuiPopupFlags popup_flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPlotLines(byte* label, float* values, int values_count, int values_offset, byte* overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride);
+        public static extern void igPlotHistogram_FloatPtr(byte* label, float* values, int values_count, int values_offset, byte* overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPopAllowKeyboardFocus();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPopButtonRepeat();
+        public static extern void igPlotLines_FloatPtr(byte* label, float* values, int values_count, int values_offset, byte* overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPopClipRect();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -439,6 +477,8 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPopID();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igPopItemFlag();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPopItemWidth();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPopStyleColor(int count);
@@ -449,54 +489,62 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igProgressBar(float fraction, Vector2 size_arg, byte* overlay);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushAllowKeyboardFocus(byte allow_keyboard_focus);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushButtonRepeat(byte repeat);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, byte intersect_with_current_clip_rect);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPushFont(ImFont* font);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushIDStr(byte* str_id);
+        public static extern void igPushID_Str(byte* str_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igPushID_StrStr(byte* str_id_begin, byte* str_id_end);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushIDRange(byte* str_id_begin, byte* str_id_end);
+        public static extern void igPushID_Ptr(void* ptr_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushIDPtr(void* ptr_id);
+        public static extern void igPushID_Int(int int_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushIDInt(int int_id);
+        public static extern void igPushItemFlag(ImGuiItemFlags option, byte enabled);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPushItemWidth(float item_width);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushStyleColorU32(ImGuiCol idx, uint col);
+        public static extern void igPushStyleColor_U32(ImGuiCol idx, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushStyleColor(ImGuiCol idx, Vector4 col);
+        public static extern void igPushStyleColor_Vec4(ImGuiCol idx, Vector4 col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushStyleVarFloat(ImGuiStyleVar idx, float val);
+        public static extern void igPushStyleVar_Float(ImGuiStyleVar idx, float val);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igPushStyleVarVec2(ImGuiStyleVar idx, Vector2 val);
+        public static extern void igPushStyleVar_Vec2(ImGuiStyleVar idx, Vector2 val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igPushStyleVarX(ImGuiStyleVar idx, float val_x);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igPushStyleVarY(ImGuiStyleVar idx, float val_y);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igPushTextWrapPos(float wrap_local_pos_x);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igRadioButtonBool(byte* label, byte active);
+        public static extern byte igRadioButton_Bool(byte* label, byte active);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igRadioButtonIntPtr(byte* label, int* v, int v_button);
+        public static extern byte igRadioButton_IntPtr(byte* label, int* v, int v_button);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igRender();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igResetMouseDragDelta(int button);
+        public static extern void igRenderPlatformWindowsDefault(void* platform_render_arg, void* renderer_render_arg);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSameLine(float local_pos_x, float spacing_w);
+        public static extern void igResetMouseDragDelta(ImGuiMouseButton button);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSameLine(float offset_from_start_x, float spacing);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSaveIniSettingsToDisk(byte* ini_filename);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte* igSaveIniSettingsToMemory(uint* out_ini_size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSelectable(byte* label, byte selected, ImGuiSelectableFlags flags, Vector2 size);
+        public static extern byte igSelectable_Bool(byte* label, byte selected, ImGuiSelectableFlags flags, Vector2 size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSelectableBoolPtr(byte* label, byte* p_selected, ImGuiSelectableFlags flags, Vector2 size);
+        public static extern byte igSelectable_BoolPtr(byte* label, byte* p_selected, ImGuiSelectableFlags flags, Vector2 size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSeparator();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSeparatorText(byte* label);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetAllocatorFunctions(IntPtr alloc_func, IntPtr free_func, void* user_data);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetClipboardText(byte* text);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetColorEditOptions(ImGuiColorEditFlags flags);
@@ -515,39 +563,69 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetCursorScreenPos(Vector2 pos);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSetDragDropPayload(byte* type, void* data, uint size, ImGuiCond cond);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetItemAllowOverlap();
+        public static extern byte igSetDragDropPayload(byte* type, void* data, uint sz, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetItemDefaultFocus();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetItemKeyOwner_Nil(ImGuiKey key);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetItemTooltip(byte* fmt);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetKeyboardFocusHere(int offset);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetMouseCursor(ImGuiMouseCursor type);
+        public static extern void igSetMouseCursor(ImGuiMouseCursor cursor_type);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNavCursorVisible(byte visible);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextFrameWantCaptureKeyboard(byte want_capture_keyboard);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextFrameWantCaptureMouse(byte want_capture_mouse);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextItemAllowOverlap();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextItemOpen(byte is_open, ImGuiCond cond);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextItemSelectionUserData(long selection_user_data);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetNextTreeNodeOpen(byte is_open, ImGuiCond cond);
+        public static extern void igSetNextItemShortcut(ImGuiKey key_chord, ImGuiInputFlags flags);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextItemStorageID(uint storage_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextItemWidth(float item_width);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowBgAlpha(float alpha);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextWindowClass(ImGuiWindowClass* window_class);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowCollapsed(byte collapsed, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowContentSize(Vector2 size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextWindowDockID(uint dock_id, ImGuiCond cond);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowFocus();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowPos(Vector2 pos, ImGuiCond cond, Vector2 pivot);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetNextWindowScroll(Vector2 scroll);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowSize(Vector2 size, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback, void* custom_callback_data);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetScrollFromPosY(float local_y, float center_y_ratio);
+        public static extern void igSetNextWindowViewport(uint viewport_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetScrollFromPosX_Float(float local_x, float center_x_ratio);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetScrollFromPosY_Float(float local_y, float center_y_ratio);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igSetScrollHereX(float center_x_ratio);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetScrollHereY(float center_y_ratio);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetScrollX(float scroll_x);
+        public static extern void igSetScrollX_Float(float scroll_x);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetScrollY(float scroll_y);
+        public static extern void igSetScrollY_Float(float scroll_y);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetStateStorage(ImGuiStorage* storage);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -555,30 +633,36 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetTooltip(byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowCollapsedBool(byte collapsed, ImGuiCond cond);
+        public static extern void igSetWindowCollapsed_Bool(byte collapsed, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowCollapsedStr(byte* name, byte collapsed, ImGuiCond cond);
+        public static extern void igSetWindowCollapsed_Str(byte* name, byte collapsed, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowFocus();
+        public static extern void igSetWindowFocus_Nil();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowFocusStr(byte* name);
+        public static extern void igSetWindowFocus_Str(byte* name);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igSetWindowFontScale(float scale);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowPosVec2(Vector2 pos, ImGuiCond cond);
+        public static extern void igSetWindowPos_Vec2(Vector2 pos, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowPosStr(byte* name, Vector2 pos, ImGuiCond cond);
+        public static extern void igSetWindowPos_Str(byte* name, Vector2 pos, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowSizeVec2(Vector2 size, ImGuiCond cond);
+        public static extern void igSetWindowSize_Vec2(Vector2 size, ImGuiCond cond);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igSetWindowSizeStr(byte* name, Vector2 size, ImGuiCond cond);
+        public static extern void igSetWindowSize_Str(byte* name, Vector2 size, ImGuiCond cond);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igShortcut_Nil(ImGuiKey key_chord, ImGuiInputFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igShowAboutWindow(byte* p_open);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igShowDebugLogWindow(byte* p_open);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igShowDemoWindow(byte* p_open);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igShowFontSelector(byte* label);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igShowIDStackToolWindow(byte* p_open);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igShowMetricsWindow(byte* p_open);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igShowStyleEditor(ImGuiStyle* @ref);
@@ -587,27 +671,27 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igShowUserGuide();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderAngle(byte* label, float* v_rad, float v_degrees_min, float v_degrees_max, byte* format);
+        public static extern byte igSliderAngle(byte* label, float* v_rad, float v_degrees_min, float v_degrees_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderFloat(byte* label, float* v, float v_min, float v_max, byte* format, float power);
+        public static extern byte igSliderFloat(byte* label, float* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderFloat2(byte* label, Vector2* v, float v_min, float v_max, byte* format, float power);
+        public static extern byte igSliderFloat2(byte* label, Vector2* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderFloat3(byte* label, Vector3* v, float v_min, float v_max, byte* format, float power);
+        public static extern byte igSliderFloat3(byte* label, Vector3* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderFloat4(byte* label, Vector4* v, float v_min, float v_max, byte* format, float power);
+        public static extern byte igSliderFloat4(byte* label, Vector4* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderInt(byte* label, int* v, int v_min, int v_max, byte* format);
+        public static extern byte igSliderInt(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderInt2(byte* label, int* v, int v_min, int v_max, byte* format);
+        public static extern byte igSliderInt2(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderInt3(byte* label, int* v, int v_min, int v_max, byte* format);
+        public static extern byte igSliderInt3(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderInt4(byte* label, int* v, int v_min, int v_max, byte* format);
+        public static extern byte igSliderInt4(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderScalar(byte* label, ImGuiDataType data_type, void* v, void* v_min, void* v_max, byte* format, float power);
+        public static extern byte igSliderScalar(byte* label, ImGuiDataType data_type, void* p_data, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igSliderScalarN(byte* label, ImGuiDataType data_type, void* v, int components, void* v_min, void* v_max, byte* format, float power);
+        public static extern byte igSliderScalarN(byte* label, ImGuiDataType data_type, void* p_data, int components, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte igSmallButton(byte* label);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -619,151 +703,239 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igStyleColorsLight(ImGuiStyle* dst);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igTabItemButton(byte* label, ImGuiTabItemFlags flags);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableAngledHeadersRow();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int igTableGetColumnCount();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiTableColumnFlags igTableGetColumnFlags(int column_n);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int igTableGetColumnIndex();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* igTableGetColumnName_Int(int column_n);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int igTableGetHoveredColumn();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int igTableGetRowIndex();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiTableSortSpecs* igTableGetSortSpecs();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableHeader(byte* label);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableHeadersRow();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igTableNextColumn();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableNextRow(ImGuiTableRowFlags row_flags, float min_row_height);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableSetBgColor(ImGuiTableBgTarget target, uint color, int column_n);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableSetColumnEnabled(int column_n, byte v);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igTableSetColumnIndex(int column_n);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableSetupColumn(byte* label, ImGuiTableColumnFlags flags, float init_width_or_weight, uint user_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTableSetupScrollFreeze(int cols, int rows);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igText(byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igTextColored(Vector4 col, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igTextDisabled(byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte igTextLink(byte* label);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igTextLinkOpenURL(byte* label, byte* url);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igTextUnformatted(byte* text, byte* text_end);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igTextWrapped(byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igTreeAdvanceToLabelPos();
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igTreeNodeStr(byte* label);
+        public static extern byte igTreeNode_Str(byte* label);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igTreeNodeStrStr(byte* str_id, byte* fmt);
+        public static extern byte igTreeNode_StrStr(byte* str_id, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igTreeNodePtr(void* ptr_id, byte* fmt);
+        public static extern byte igTreeNode_Ptr(void* ptr_id, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igTreeNodeExStr(byte* label, ImGuiTreeNodeFlags flags);
+        public static extern byte igTreeNodeEx_Str(byte* label, ImGuiTreeNodeFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igTreeNodeExStrStr(byte* str_id, ImGuiTreeNodeFlags flags, byte* fmt);
+        public static extern byte igTreeNodeEx_StrStr(byte* str_id, ImGuiTreeNodeFlags flags, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igTreeNodeExPtr(void* ptr_id, ImGuiTreeNodeFlags flags, byte* fmt);
+        public static extern byte igTreeNodeEx_Ptr(void* ptr_id, ImGuiTreeNodeFlags flags, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igTreePop();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igTreePushStr(byte* str_id);
+        public static extern void igTreePush_Str(byte* str_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igTreePushPtr(void* ptr_id);
+        public static extern void igTreePush_Ptr(void* ptr_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void igUnindent(float indent_w);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igValueBool(byte* prefix, byte b);
+        public static extern void igUpdatePlatformWindows();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void igValue_Bool(byte* prefix, byte b);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igValueInt(byte* prefix, int v);
+        public static extern void igValue_Int(byte* prefix, int v);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igValueUint(byte* prefix, uint v);
+        public static extern void igValue_Uint(byte* prefix, uint v);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void igValueFloat(byte* prefix, float v, byte* float_format);
+        public static extern void igValue_Float(byte* prefix, float v, byte* float_format);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igVSliderFloat(byte* label, Vector2 size, float* v, float v_min, float v_max, byte* format, float power);
+        public static extern byte igVSliderFloat(byte* label, Vector2 size, float* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igVSliderInt(byte* label, Vector2 size, int* v, int v_min, int v_max, byte* format);
+        public static extern byte igVSliderInt(byte* label, Vector2 size, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte igVSliderScalar(byte* label, Vector2 size, ImGuiDataType data_type, void* v, void* v_min, void* v_max, byte* format, float power);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "ImColor_HSV_nonUDT2")]
-        public static extern ImColor ImColor_HSV(ImColor* self, float h, float s, float v, float a);
+        public static extern byte igVSliderScalar(byte* label, Vector2 size, ImGuiDataType data_type, void* p_data, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImColor_ImColor();
+        public static extern void ImColor_destroy(ImColor* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImColor_ImColorInt(int r, int g, int b, int a);
+        public static extern void ImColor_HSV(ImColor* pOut, float h, float s, float v, float a);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImColor_ImColorU32(uint rgba);
+        public static extern ImColor* ImColor_ImColor_Nil();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImColor_ImColorFloat(float r, float g, float b, float a);
+        public static extern ImColor* ImColor_ImColor_Float(float r, float g, float b, float a);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImColor_ImColorVec4(Vector4 col);
+        public static extern ImColor* ImColor_ImColor_Vec4(Vector4 col);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImColor* ImColor_ImColor_Int(int r, int g, int b, int a);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImColor* ImColor_ImColor_U32(uint rgba);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImColor_SetHSV(ImColor* self, float h, float s, float v, float a);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawCmd_ImDrawCmd();
+        public static extern void ImDrawCmd_destroy(ImDrawCmd* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ImDrawCmd_GetTexID(ImDrawCmd* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawCmd* ImDrawCmd_ImDrawCmd();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawData_AddDrawList(ImDrawData* self, ImDrawList* draw_list);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawData_Clear(ImDrawData* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawData_DeIndexAllBuffers(ImDrawData* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawData_ImDrawData();
+        public static extern void ImDrawData_destroy(ImDrawData* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawData* ImDrawData_ImDrawData();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawData_ScaleClipRects(ImDrawData* self, Vector2 fb_scale);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ImDrawList__CalcCircleAutoSegmentCount(ImDrawList* self, float radius);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList__ClearFreeMemory(ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList__OnChangedClipRect(ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList__OnChangedTextureID(ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList__OnChangedVtxOffset(ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList__PathArcToFastEx(ImDrawList* self, Vector2 center, float radius, int a_min_sample, int a_max_sample, int a_step);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList__PathArcToN(ImDrawList* self, Vector2 center, float radius, float a_min, float a_max, int num_segments);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawData_ScaleClipRects(ImDrawData* self, Vector2 sc);
+        public static extern void ImDrawList__PopUnusedDrawCmd(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddBezierCurve(ImDrawList* self, Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness, int num_segments);
+        public static extern void ImDrawList__ResetForNewFrame(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddCallback(ImDrawList* self, IntPtr callback, void* callback_data);
+        public static extern void ImDrawList__SetTextureID(ImDrawList* self, IntPtr texture_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddCircle(ImDrawList* self, Vector2 centre, float radius, uint col, int num_segments, float thickness);
+        public static extern void ImDrawList__TryMergeDrawCmds(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddCircleFilled(ImDrawList* self, Vector2 centre, float radius, uint col, int num_segments);
+        public static extern void ImDrawList_AddBezierCubic(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness, int num_segments);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_AddBezierQuadratic(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness, int num_segments);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_AddCallback(ImDrawList* self, IntPtr callback, void* userdata, uint userdata_size);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_AddCircle(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments, float thickness);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_AddCircleFilled(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_AddConcavePolyFilled(ImDrawList* self, Vector2* points, int num_points, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_AddConvexPolyFilled(ImDrawList* self, Vector2* points, int num_points, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_AddDrawCmd(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddImage(ImDrawList* self, IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col);
+        public static extern void ImDrawList_AddEllipse(ImDrawList* self, Vector2 center, Vector2 radius, uint col, float rot, int num_segments, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddImageQuad(ImDrawList* self, IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col);
+        public static extern void ImDrawList_AddEllipseFilled(ImDrawList* self, Vector2 center, Vector2 radius, uint col, float rot, int num_segments);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddImageRounded(ImDrawList* self, IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding, int rounding_corners);
+        public static extern void ImDrawList_AddImage(ImDrawList* self, IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddLine(ImDrawList* self, Vector2 a, Vector2 b, uint col, float thickness);
+        public static extern void ImDrawList_AddImageQuad(ImDrawList* self, IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddPolyline(ImDrawList* self, Vector2* points, int num_points, uint col, byte closed, float thickness);
+        public static extern void ImDrawList_AddImageRounded(ImDrawList* self, IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding, ImDrawFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddQuad(ImDrawList* self, Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col, float thickness);
+        public static extern void ImDrawList_AddLine(ImDrawList* self, Vector2 p1, Vector2 p2, uint col, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddQuadFilled(ImDrawList* self, Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col);
+        public static extern void ImDrawList_AddNgon(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddRect(ImDrawList* self, Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags, float thickness);
+        public static extern void ImDrawList_AddNgonFilled(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddRectFilled(ImDrawList* self, Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags);
+        public static extern void ImDrawList_AddPolyline(ImDrawList* self, Vector2* points, int num_points, uint col, ImDrawFlags flags, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddRectFilledMultiColor(ImDrawList* self, Vector2 a, Vector2 b, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left);
+        public static extern void ImDrawList_AddQuad(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddText(ImDrawList* self, Vector2 pos, uint col, byte* text_begin, byte* text_end);
+        public static extern void ImDrawList_AddQuadFilled(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddTextFontPtr(ImDrawList* self, ImFont* font, float font_size, Vector2 pos, uint col, byte* text_begin, byte* text_end, float wrap_width, Vector4* cpu_fine_clip_rect);
+        public static extern void ImDrawList_AddRect(ImDrawList* self, Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddTriangle(ImDrawList* self, Vector2 a, Vector2 b, Vector2 c, uint col, float thickness);
+        public static extern void ImDrawList_AddRectFilled(ImDrawList* self, Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_AddTriangleFilled(ImDrawList* self, Vector2 a, Vector2 b, Vector2 c, uint col);
+        public static extern void ImDrawList_AddRectFilledMultiColor(ImDrawList* self, Vector2 p_min, Vector2 p_max, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_ChannelsMerge(ImDrawList* self);
+        public static extern void ImDrawList_AddText_Vec2(ImDrawList* self, Vector2 pos, uint col, byte* text_begin, byte* text_end);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_ChannelsSetCurrent(ImDrawList* self, int channel_index);
+        public static extern void ImDrawList_AddText_FontPtr(ImDrawList* self, ImFont* font, float font_size, Vector2 pos, uint col, byte* text_begin, byte* text_end, float wrap_width, Vector4* cpu_fine_clip_rect);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_ChannelsSplit(ImDrawList* self, int channels_count);
+        public static extern void ImDrawList_AddTriangle(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_Clear(ImDrawList* self);
+        public static extern void ImDrawList_AddTriangleFilled(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_ClearFreeMemory(ImDrawList* self);
+        public static extern void ImDrawList_ChannelsMerge(ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_ChannelsSetCurrent(ImDrawList* self, int n);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_ChannelsSplit(ImDrawList* self, int count);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImDrawList* ImDrawList_CloneOutput(ImDrawList* self);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "ImDrawList_GetClipRectMax_nonUDT2")]
-        public static extern Vector2 ImDrawList_GetClipRectMax(ImDrawList* self);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "ImDrawList_GetClipRectMin_nonUDT2")]
-        public static extern Vector2 ImDrawList_GetClipRectMin(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_ImDrawList(IntPtr shared_data);
+        public static extern void ImDrawList_destroy(ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_GetClipRectMax(Vector2* pOut, ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_GetClipRectMin(Vector2* pOut, ImDrawList* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawList* ImDrawList_ImDrawList(IntPtr shared_data);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_PathArcTo(ImDrawList* self, Vector2 center, float radius, float a_min, float a_max, int num_segments);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_PathArcTo(ImDrawList* self, Vector2 centre, float radius, float a_min, float a_max, int num_segments);
+        public static extern void ImDrawList_PathArcToFast(ImDrawList* self, Vector2 center, float radius, int a_min_of_12, int a_max_of_12);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_PathArcToFast(ImDrawList* self, Vector2 centre, float radius, int a_min_of_12, int a_max_of_12);
+        public static extern void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self, Vector2 p2, Vector2 p3, Vector2 p4, int num_segments);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_PathBezierCurveTo(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, int num_segments);
+        public static extern void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self, Vector2 p2, Vector2 p3, int num_segments);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PathClear(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_PathEllipticalArcTo(ImDrawList* self, Vector2 center, Vector2 radius, float rot, float a_min, float a_max, int num_segments);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_PathFillConcave(ImDrawList* self, uint col);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PathFillConvex(ImDrawList* self, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PathLineTo(ImDrawList* self, Vector2 pos);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self, Vector2 pos);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_PathRect(ImDrawList* self, Vector2 rect_min, Vector2 rect_max, float rounding, int rounding_corners_flags);
+        public static extern void ImDrawList_PathRect(ImDrawList* self, Vector2 rect_min, Vector2 rect_max, float rounding, ImDrawFlags flags);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_PathStroke(ImDrawList* self, uint col, byte closed, float thickness);
+        public static extern void ImDrawList_PathStroke(ImDrawList* self, uint col, ImDrawFlags flags, float thickness);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PopClipRect(ImDrawList* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -777,6 +949,8 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PrimReserve(ImDrawList* self, int idx_count, int vtx_count);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawList_PrimUnreserve(ImDrawList* self, int idx_count, int vtx_count);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PrimVtx(ImDrawList* self, Vector2 pos, Vector2 uv, uint col);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PrimWriteIdx(ImDrawList* self, ushort idx);
@@ -789,22 +963,34 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImDrawList_PushTextureID(ImDrawList* self, IntPtr texture_id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_UpdateClipRect(ImDrawList* self);
+        public static extern void ImDrawListSplitter_Clear(ImDrawListSplitter* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawListSplitter_destroy(ImDrawListSplitter* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImDrawListSplitter_Merge(ImDrawListSplitter* self, ImDrawList* draw_list);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImDrawList_UpdateTextureID(ImDrawList* self);
+        public static extern void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self, ImDrawList* draw_list, int channel_idx);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFont_AddGlyph(ImFont* self, ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x);
+        public static extern void ImDrawListSplitter_Split(ImDrawListSplitter* self, ImDrawList* draw_list, int count);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFont_AddGlyph(ImFont* self, ImFontConfig* src_cfg, ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFont_AddRemapChar(ImFont* self, ushort dst, ushort src, byte overwrite_dst);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFont_BuildLookupTable(ImFont* self);
-        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl, EntryPoint = "ImFont_CalcTextSizeA_nonUDT2")]
-        public static extern Vector2 ImFont_CalcTextSizeA(ImFont* self, float size, float max_width, float wrap_width, byte* text_begin, byte* text_end, byte** remaining);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFont_CalcTextSizeA(Vector2* pOut, ImFont* self, float size, float max_width, float wrap_width, byte* text_begin, byte* text_end, byte** remaining);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte* ImFont_CalcWordWrapPositionA(ImFont* self, float scale, byte* text, byte* text_end, float wrap_width);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFont_ClearOutputData(ImFont* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFont_destroy(ImFont* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImFontGlyph* ImFont_FindGlyph(ImFont* self, ushort c);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self, ushort c);
@@ -815,7 +1001,9 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFont_GrowIndex(ImFont* self, int new_size);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFont_ImFont();
+        public static extern ImFont* ImFont_ImFont();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImFont_IsGlyphRangeUnused(ImFont* self, uint c_begin, uint c_last);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImFont_IsLoaded(ImFont* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -823,11 +1011,11 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFont_RenderText(ImFont* self, ImDrawList* draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, byte* text_begin, byte* text_end, float wrap_width, byte cpu_fine_clip);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFont_SetFallbackChar(ImFont* self, ushort c);
+        public static extern void ImFont_SetGlyphVisible(ImFont* self, ushort c, byte visible);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self, ImFont* font, ushort id, int width, int height, float advance_x, Vector2 offset);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self, uint id, int width, int height);
+        public static extern int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self, int width, int height);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImFont* ImFontAtlas_AddFont(ImFontAtlas* self, ImFontConfig* font_cfg);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -837,13 +1025,13 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self, byte* compressed_font_data_base85, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self, void* compressed_font_data, int compressed_font_size, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);
+        public static extern ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self, void* compressed_font_data, int compressed_font_data_size, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self, void* font_data, int font_size, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);
+        public static extern ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self, void* font_data, int font_data_size, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImFontAtlas_Build(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self, CustomRect* rect, Vector2* out_uv_min, Vector2* out_uv_max);
+        public static extern void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self, ImFontAtlasCustomRect* rect, Vector2* out_uv_min, Vector2* out_uv_max);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontAtlas_Clear(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -853,7 +1041,9 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontAtlas_ClearTexData(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern CustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self, int index);
+        public static extern void ImFontAtlas_destroy(ImFontAtlas* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self, int index);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ushort* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -863,25 +1053,41 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ushort* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ushort* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ushort* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ushort* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern ushort* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ushort* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self, ImGuiMouseCursor cursor, Vector2* out_offset, Vector2* out_size, Vector2* out_uv_border, Vector2* out_uv_fill);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self, byte** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self, IntPtr* out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self, byte** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFontAtlas_ImFontAtlas();
+        public static extern void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self, IntPtr* out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImFontAtlas* ImFontAtlas_ImFontAtlas();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImFontAtlas_IsBuilt(ImFontAtlas* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontAtlas_SetTexID(ImFontAtlas* self, IntPtr id);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFontConfig_ImFontConfig();
+        public static extern void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFontConfig_destroy(ImFontConfig* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImFontConfig* ImFontConfig_ImFontConfig();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self, ushort c);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -891,41 +1097,93 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self, ImVector* out_ranges);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self, int n);
+        public static extern void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder();
+        public static extern byte ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self, uint n);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self, int n);
+        public static extern ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self, uint n);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr* ImGuiFreeType_GetBuilderForFreeType();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiInputTextCallbackData_ClearSelection(ImGuiInputTextCallbackData* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self, int pos, int bytes_count);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiInputTextCallbackData_ImGuiInputTextCallbackData();
+        public static extern ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self, int pos, byte* text, byte* text_end);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiIO_AddInputCharacter(ImGuiIO* self, ushort c);
+        public static extern void ImGuiInputTextCallbackData_SelectAll(ImGuiInputTextCallbackData* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddFocusEvent(ImGuiIO* self, byte focused);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddInputCharacter(ImGuiIO* self, uint c);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self, byte* str);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiIO_ClearInputCharacters(ImGuiIO* self);
+        public static extern void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self, ushort c);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiIO_ImGuiIO();
+        public static extern void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self, ImGuiKey key, byte down, float v);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddKeyEvent(ImGuiIO* self, ImGuiKey key, byte down);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self, int button, byte down);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddMousePosEvent(ImGuiIO* self, float x, float y);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddMouseSourceEvent(ImGuiIO* self, ImGuiMouseSource source);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self, uint id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self, float wheel_x, float wheel_y);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_ClearEventsQueue(ImGuiIO* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_ClearInputKeys(ImGuiIO* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_ClearInputMouse(ImGuiIO* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_destroy(ImGuiIO* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiIO* ImGuiIO_ImGuiIO();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self, byte accepting_events);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self, ImGuiKey key, int native_keycode, int native_scancode, int native_legacy_index);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiListClipper_Begin(ImGuiListClipper* self, int items_count, float items_height);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiListClipper_destroy(ImGuiListClipper* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiListClipper_End(ImGuiListClipper* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiListClipper_ImGuiListClipper(int items_count, float items_height);
+        public static extern ImGuiListClipper* ImGuiListClipper_ImGuiListClipper();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiListClipper_IncludeItemByIndex(ImGuiListClipper* self, int item_index);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiListClipper_IncludeItemsByIndex(ImGuiListClipper* self, int item_begin, int item_end);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiListClipper_SeekCursorForItem(ImGuiListClipper* self, int item_index);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiListClipper_Step(ImGuiListClipper* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiOnceUponAFrame_ImGuiOnceUponAFrame();
+        public static extern void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiPayload_Clear(ImGuiPayload* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiPayload_ImGuiPayload();
+        public static extern void ImGuiPayload_destroy(ImGuiPayload* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiPayload* ImGuiPayload_ImGuiPayload();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiPayload_IsDataType(ImGuiPayload* self, byte* type);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -933,6 +1191,42 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiPayload_IsPreview(ImGuiPayload* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionBasicStorage_ApplyRequests(ImGuiSelectionBasicStorage* self, ImGuiMultiSelectIO* ms_io);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionBasicStorage_Clear(ImGuiSelectionBasicStorage* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuiSelectionBasicStorage_Contains(ImGuiSelectionBasicStorage* self, uint id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionBasicStorage_destroy(ImGuiSelectionBasicStorage* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuiSelectionBasicStorage_GetNextSelectedItem(ImGuiSelectionBasicStorage* self, void** opaque_it, uint* out_id);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern uint ImGuiSelectionBasicStorage_GetStorageIdFromIndex(ImGuiSelectionBasicStorage* self, int idx);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiSelectionBasicStorage* ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionBasicStorage_SetItemSelected(ImGuiSelectionBasicStorage* self, uint id, byte selected);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionBasicStorage_Swap(ImGuiSelectionBasicStorage* self, ImGuiSelectionBasicStorage* r);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionExternalStorage_ApplyRequests(ImGuiSelectionExternalStorage* self, ImGuiMultiSelectIO* ms_io);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiSelectionExternalStorage_destroy(ImGuiSelectionExternalStorage* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiSelectionExternalStorage* ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiStorage_BuildSortByKey(ImGuiStorage* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiStorage_Clear(ImGuiStorage* self);
@@ -963,11 +1257,31 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiStorage_SetVoidPtr(ImGuiStorage* self, uint key, void* val);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiStyle_ImGuiStyle();
+        public static extern void ImGuiStoragePair_destroy(ImGuiStoragePair* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Int(uint _key, int _val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(uint _key, float _val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(uint _key, void* _val);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiStyle_destroy(ImGuiStyle* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiStyle* ImGuiStyle_ImGuiStyle();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self, float scale_factor);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiTextBuffer_appendf(ImGuiTextBuffer* self, byte* fmt);
+        public static extern void ImGuiTableColumnSortSpecs_destroy(ImGuiTableColumnSortSpecs* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiTableColumnSortSpecs* ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiTextBuffer_append(ImGuiTextBuffer* self, byte* str, byte* str_end);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiTextBuffer_appendf(ImGuiTextBuffer* buffer, byte* fmt);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte* ImGuiTextBuffer_begin(ImGuiTextBuffer* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -975,11 +1289,13 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiTextBuffer_clear(ImGuiTextBuffer* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiTextBuffer_empty(ImGuiTextBuffer* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte* ImGuiTextBuffer_end(ImGuiTextBuffer* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiTextBuffer_ImGuiTextBuffer();
+        public static extern ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self, int capacity);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
@@ -989,38 +1305,48 @@ public static unsafe partial class ImGuiNative
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern void ImGuiTextFilter_Clear(ImGuiTextFilter* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiTextFilter_destroy(ImGuiTextFilter* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiTextFilter_Draw(ImGuiTextFilter* self, byte* label, float width);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImGuiTextFilter_ImGuiTextFilter(byte* default_filter);
+        public static extern ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(byte* default_filter);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiTextFilter_IsActive(ImGuiTextFilter* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
         public static extern byte ImGuiTextFilter_PassFilter(ImGuiTextFilter* self, byte* text, byte* text_end);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImVec2_ImVec2();
+        public static extern void ImGuiTextRange_destroy(ImGuiTextRange* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuiTextRange_empty(ImGuiTextRange* self);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Nil();
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Str(byte* _b, byte* _e);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiTextRange_split(ImGuiTextRange* self, byte separator, ImVector* @out);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImVec2_ImVec2Float(float _x, float _y);
+        public static extern void ImGuiViewport_destroy(ImGuiViewport* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImVec4_ImVec4();
+        public static extern void ImGuiViewport_GetCenter(Vector2* pOut, ImGuiViewport* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ImVec4_ImVec4Float(float _x, float _y, float _z, float _w);
+        public static extern void ImGuiViewport_GetWorkCenter(Vector2* pOut, ImGuiViewport* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void Pair_PairInt(uint _key, int _val_i);
+        public static extern ImGuiViewport* ImGuiViewport_ImGuiViewport();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void Pair_PairFloat(uint _key, float _val_f);
+        public static extern void ImGuiWindowClass_destroy(ImGuiWindowClass* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void Pair_PairPtr(uint _key, void* _val_p);
+        public static extern ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte* TextRange_begin(TextRange* self);
+        public static extern void ImVec2_destroy(Vector2* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte TextRange_empty(TextRange* self);
+        public static extern Vector2* ImVec2_ImVec2_Nil();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte* TextRange_end(TextRange* self);
+        public static extern Vector2* ImVec2_ImVec2_Float(float _x, float _y);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void TextRange_split(TextRange* self, byte separator, ImVector* @out);
+        public static extern void ImVec4_destroy(Vector4* self);
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void TextRange_TextRange();
+        public static extern Vector4* ImVec4_ImVec4_Nil();
         [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void TextRange_TextRangeStr(byte* _b, byte* _e);
+        public static extern Vector4* ImVec4_ImVec4_Float(float _x, float _y, float _z, float _w);
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiNavInput.gen.cs b/src/ImGui.NET/Generated/ImGuiNavInput.gen.cs
deleted file mode 100644
index 0400d811..00000000
--- a/src/ImGui.NET/Generated/ImGuiNavInput.gen.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-namespace ImGuiNET
-{
-    public enum ImGuiNavInput
-    {
-        Activate = 0,
-        Cancel = 1,
-        Input = 2,
-        Menu = 3,
-        DpadLeft = 4,
-        DpadRight = 5,
-        DpadUp = 6,
-        DpadDown = 7,
-        LStickLeft = 8,
-        LStickRight = 9,
-        LStickUp = 10,
-        LStickDown = 11,
-        FocusPrev = 12,
-        FocusNext = 13,
-        TweakSlow = 14,
-        TweakFast = 15,
-        KeyMenu = 16,
-        KeyLeft = 17,
-        KeyRight = 18,
-        KeyUp = 19,
-        KeyDown = 20,
-        COUNT = 21,
-        InternalStart = KeyMenu,
-    }
-}
diff --git a/src/ImGui.NET/Generated/ImGuiOnceUponAFrame.gen.cs b/src/ImGui.NET/Generated/ImGuiOnceUponAFrame.gen.cs
index e3c648cc..d6d7db8d 100644
--- a/src/ImGui.NET/Generated/ImGuiOnceUponAFrame.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiOnceUponAFrame.gen.cs
@@ -18,5 +18,9 @@ public unsafe partial struct ImGuiOnceUponAFramePtr
         public static implicit operator ImGuiOnceUponAFrame* (ImGuiOnceUponAFramePtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiOnceUponAFramePtr(IntPtr nativePtr) => new ImGuiOnceUponAFramePtr(nativePtr);
         public ref int RefFrame => ref Unsafe.AsRef<int>(&NativePtr->RefFrame);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiOnceUponAFrame_destroy((ImGuiOnceUponAFrame*)(NativePtr));
+        }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiPayload.gen.cs b/src/ImGui.NET/Generated/ImGuiPayload.gen.cs
index f0a9e318..6f4ba795 100644
--- a/src/ImGui.NET/Generated/ImGuiPayload.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiPayload.gen.cs
@@ -34,8 +34,41 @@ public unsafe partial struct ImGuiPayloadPtr
         public ref bool Delivery => ref Unsafe.AsRef<bool>(&NativePtr->Delivery);
         public void Clear()
         {
-            ImGuiNative.ImGuiPayload_Clear(NativePtr);
+            ImGuiNative.ImGuiPayload_Clear((ImGuiPayload*)(NativePtr));
         }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiPayload_destroy((ImGuiPayload*)(NativePtr));
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public bool IsDataType(ReadOnlySpan<char> type)
+        {
+            byte* native_type;
+            int type_byteCount = 0;
+            if (type != null)
+            {
+                type_byteCount = Encoding.UTF8.GetByteCount(type);
+                if (type_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_type = Util.Allocate(type_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_type_stackBytes = stackalloc byte[type_byteCount + 1];
+                    native_type = native_type_stackBytes;
+                }
+                int native_type_offset = Util.GetUtf8(type, native_type, type_byteCount);
+                native_type[native_type_offset] = 0;
+            }
+            else { native_type = null; }
+            byte ret = ImGuiNative.ImGuiPayload_IsDataType((ImGuiPayload*)(NativePtr), native_type);
+            if (type_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_type);
+            }
+            return ret != 0;
+        }
+#endif
         public bool IsDataType(string type)
         {
             byte* native_type;
@@ -56,7 +89,7 @@ public bool IsDataType(string type)
                 native_type[native_type_offset] = 0;
             }
             else { native_type = null; }
-            byte ret = ImGuiNative.ImGuiPayload_IsDataType(NativePtr, native_type);
+            byte ret = ImGuiNative.ImGuiPayload_IsDataType((ImGuiPayload*)(NativePtr), native_type);
             if (type_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_type);
@@ -65,12 +98,12 @@ public bool IsDataType(string type)
         }
         public bool IsDelivery()
         {
-            byte ret = ImGuiNative.ImGuiPayload_IsDelivery(NativePtr);
+            byte ret = ImGuiNative.ImGuiPayload_IsDelivery((ImGuiPayload*)(NativePtr));
             return ret != 0;
         }
         public bool IsPreview()
         {
-            byte ret = ImGuiNative.ImGuiPayload_IsPreview(NativePtr);
+            byte ret = ImGuiNative.ImGuiPayload_IsPreview((ImGuiPayload*)(NativePtr));
             return ret != 0;
         }
     }
diff --git a/src/ImGui.NET/Generated/ImGuiPlatformIO.gen.cs b/src/ImGui.NET/Generated/ImGuiPlatformIO.gen.cs
new file mode 100644
index 00000000..5bdef45b
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiPlatformIO.gen.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiPlatformIO
+    {
+        public IntPtr Platform_GetClipboardTextFn;
+        public IntPtr Platform_SetClipboardTextFn;
+        public void* Platform_ClipboardUserData;
+        public IntPtr Platform_OpenInShellFn;
+        public void* Platform_OpenInShellUserData;
+        public IntPtr Platform_SetImeDataFn;
+        public void* Platform_ImeUserData;
+        public ushort Platform_LocaleDecimalPoint;
+        public void* Renderer_RenderState;
+        public IntPtr Platform_CreateWindow;
+        public IntPtr Platform_DestroyWindow;
+        public IntPtr Platform_ShowWindow;
+        public IntPtr Platform_SetWindowPos;
+        public IntPtr Platform_GetWindowPos;
+        public IntPtr Platform_SetWindowSize;
+        public IntPtr Platform_GetWindowSize;
+        public IntPtr Platform_SetWindowFocus;
+        public IntPtr Platform_GetWindowFocus;
+        public IntPtr Platform_GetWindowMinimized;
+        public IntPtr Platform_SetWindowTitle;
+        public IntPtr Platform_SetWindowAlpha;
+        public IntPtr Platform_UpdateWindow;
+        public IntPtr Platform_RenderWindow;
+        public IntPtr Platform_SwapBuffers;
+        public IntPtr Platform_GetWindowDpiScale;
+        public IntPtr Platform_OnChangedViewport;
+        public IntPtr Platform_GetWindowWorkAreaInsets;
+        public IntPtr Platform_CreateVkSurface;
+        public IntPtr Renderer_CreateWindow;
+        public IntPtr Renderer_DestroyWindow;
+        public IntPtr Renderer_SetWindowSize;
+        public IntPtr Renderer_RenderWindow;
+        public IntPtr Renderer_SwapBuffers;
+        public ImVector Monitors;
+        public ImVector Viewports;
+    }
+    public unsafe partial struct ImGuiPlatformIOPtr
+    {
+        public ImGuiPlatformIO* NativePtr { get; }
+        public ImGuiPlatformIOPtr(ImGuiPlatformIO* nativePtr) => NativePtr = nativePtr;
+        public ImGuiPlatformIOPtr(IntPtr nativePtr) => NativePtr = (ImGuiPlatformIO*)nativePtr;
+        public static implicit operator ImGuiPlatformIOPtr(ImGuiPlatformIO* nativePtr) => new ImGuiPlatformIOPtr(nativePtr);
+        public static implicit operator ImGuiPlatformIO* (ImGuiPlatformIOPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiPlatformIOPtr(IntPtr nativePtr) => new ImGuiPlatformIOPtr(nativePtr);
+        public ref IntPtr Platform_GetClipboardTextFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetClipboardTextFn);
+        public ref IntPtr Platform_SetClipboardTextFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetClipboardTextFn);
+        public IntPtr Platform_ClipboardUserData { get => (IntPtr)NativePtr->Platform_ClipboardUserData; set => NativePtr->Platform_ClipboardUserData = (void*)value; }
+        public ref IntPtr Platform_OpenInShellFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_OpenInShellFn);
+        public IntPtr Platform_OpenInShellUserData { get => (IntPtr)NativePtr->Platform_OpenInShellUserData; set => NativePtr->Platform_OpenInShellUserData = (void*)value; }
+        public ref IntPtr Platform_SetImeDataFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetImeDataFn);
+        public IntPtr Platform_ImeUserData { get => (IntPtr)NativePtr->Platform_ImeUserData; set => NativePtr->Platform_ImeUserData = (void*)value; }
+        public ref ushort Platform_LocaleDecimalPoint => ref Unsafe.AsRef<ushort>(&NativePtr->Platform_LocaleDecimalPoint);
+        public IntPtr Renderer_RenderState { get => (IntPtr)NativePtr->Renderer_RenderState; set => NativePtr->Renderer_RenderState = (void*)value; }
+        public ref IntPtr Platform_CreateWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_CreateWindow);
+        public ref IntPtr Platform_DestroyWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_DestroyWindow);
+        public ref IntPtr Platform_ShowWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_ShowWindow);
+        public ref IntPtr Platform_SetWindowPos => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowPos);
+        public ref IntPtr Platform_GetWindowPos => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowPos);
+        public ref IntPtr Platform_SetWindowSize => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowSize);
+        public ref IntPtr Platform_GetWindowSize => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowSize);
+        public ref IntPtr Platform_SetWindowFocus => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowFocus);
+        public ref IntPtr Platform_GetWindowFocus => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowFocus);
+        public ref IntPtr Platform_GetWindowMinimized => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowMinimized);
+        public ref IntPtr Platform_SetWindowTitle => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowTitle);
+        public ref IntPtr Platform_SetWindowAlpha => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowAlpha);
+        public ref IntPtr Platform_UpdateWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_UpdateWindow);
+        public ref IntPtr Platform_RenderWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_RenderWindow);
+        public ref IntPtr Platform_SwapBuffers => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SwapBuffers);
+        public ref IntPtr Platform_GetWindowDpiScale => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowDpiScale);
+        public ref IntPtr Platform_OnChangedViewport => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_OnChangedViewport);
+        public ref IntPtr Platform_GetWindowWorkAreaInsets => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowWorkAreaInsets);
+        public ref IntPtr Platform_CreateVkSurface => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_CreateVkSurface);
+        public ref IntPtr Renderer_CreateWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_CreateWindow);
+        public ref IntPtr Renderer_DestroyWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_DestroyWindow);
+        public ref IntPtr Renderer_SetWindowSize => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_SetWindowSize);
+        public ref IntPtr Renderer_RenderWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_RenderWindow);
+        public ref IntPtr Renderer_SwapBuffers => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_SwapBuffers);
+        public ImPtrVector<ImGuiPlatformMonitorPtr> Monitors => new ImPtrVector<ImGuiPlatformMonitorPtr>(NativePtr->Monitors, Unsafe.SizeOf<ImGuiPlatformMonitor>());
+        public ImVector<ImGuiViewportPtr> Viewports => new ImVector<ImGuiViewportPtr>(NativePtr->Viewports);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiPlatformIO_destroy((ImGuiPlatformIO*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiPlatformImeData.gen.cs b/src/ImGui.NET/Generated/ImGuiPlatformImeData.gen.cs
new file mode 100644
index 00000000..fa0cdcc4
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiPlatformImeData.gen.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiPlatformImeData
+    {
+        public byte WantVisible;
+        public Vector2 InputPos;
+        public float InputLineHeight;
+    }
+    public unsafe partial struct ImGuiPlatformImeDataPtr
+    {
+        public ImGuiPlatformImeData* NativePtr { get; }
+        public ImGuiPlatformImeDataPtr(ImGuiPlatformImeData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiPlatformImeDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiPlatformImeData*)nativePtr;
+        public static implicit operator ImGuiPlatformImeDataPtr(ImGuiPlatformImeData* nativePtr) => new ImGuiPlatformImeDataPtr(nativePtr);
+        public static implicit operator ImGuiPlatformImeData* (ImGuiPlatformImeDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiPlatformImeDataPtr(IntPtr nativePtr) => new ImGuiPlatformImeDataPtr(nativePtr);
+        public ref bool WantVisible => ref Unsafe.AsRef<bool>(&NativePtr->WantVisible);
+        public ref Vector2 InputPos => ref Unsafe.AsRef<Vector2>(&NativePtr->InputPos);
+        public ref float InputLineHeight => ref Unsafe.AsRef<float>(&NativePtr->InputLineHeight);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiPlatformImeData_destroy((ImGuiPlatformImeData*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiPlatformMonitor.gen.cs b/src/ImGui.NET/Generated/ImGuiPlatformMonitor.gen.cs
new file mode 100644
index 00000000..4013834b
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiPlatformMonitor.gen.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiPlatformMonitor
+    {
+        public Vector2 MainPos;
+        public Vector2 MainSize;
+        public Vector2 WorkPos;
+        public Vector2 WorkSize;
+        public float DpiScale;
+        public void* PlatformHandle;
+    }
+    public unsafe partial struct ImGuiPlatformMonitorPtr
+    {
+        public ImGuiPlatformMonitor* NativePtr { get; }
+        public ImGuiPlatformMonitorPtr(ImGuiPlatformMonitor* nativePtr) => NativePtr = nativePtr;
+        public ImGuiPlatformMonitorPtr(IntPtr nativePtr) => NativePtr = (ImGuiPlatformMonitor*)nativePtr;
+        public static implicit operator ImGuiPlatformMonitorPtr(ImGuiPlatformMonitor* nativePtr) => new ImGuiPlatformMonitorPtr(nativePtr);
+        public static implicit operator ImGuiPlatformMonitor* (ImGuiPlatformMonitorPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiPlatformMonitorPtr(IntPtr nativePtr) => new ImGuiPlatformMonitorPtr(nativePtr);
+        public ref Vector2 MainPos => ref Unsafe.AsRef<Vector2>(&NativePtr->MainPos);
+        public ref Vector2 MainSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MainSize);
+        public ref Vector2 WorkPos => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkPos);
+        public ref Vector2 WorkSize => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkSize);
+        public ref float DpiScale => ref Unsafe.AsRef<float>(&NativePtr->DpiScale);
+        public IntPtr PlatformHandle { get => (IntPtr)NativePtr->PlatformHandle; set => NativePtr->PlatformHandle = (void*)value; }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiPlatformMonitor_destroy((ImGuiPlatformMonitor*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiPopupFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiPopupFlags.gen.cs
new file mode 100644
index 00000000..9564d98a
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiPopupFlags.gen.cs
@@ -0,0 +1,19 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiPopupFlags
+    {
+        None = 0,
+        MouseButtonLeft = 0,
+        MouseButtonRight = 1,
+        MouseButtonMiddle = 2,
+        MouseButtonMask = 31,
+        MouseButtonDefault = 1,
+        NoReopen = 32,
+        NoOpenOverExistingPopup = 128,
+        NoOpenOverItems = 256,
+        AnyPopupId = 1024,
+        AnyPopupLevel = 2048,
+        AnyPopup = 3072,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiSelectableFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiSelectableFlags.gen.cs
index dff74722..4fff23c5 100644
--- a/src/ImGui.NET/Generated/ImGuiSelectableFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiSelectableFlags.gen.cs
@@ -4,9 +4,11 @@ namespace ImGuiNET
     public enum ImGuiSelectableFlags
     {
         None = 0,
-        DontClosePopups = 1 << 0,
-        SpanAllColumns = 1 << 1,
-        AllowDoubleClick = 1 << 2,
-        Disabled = 1 << 3,
+        NoAutoClosePopups = 1,
+        SpanAllColumns = 2,
+        AllowDoubleClick = 4,
+        Disabled = 8,
+        AllowOverlap = 16,
+        Highlight = 32,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiSelectionBasicStorage.gen.cs b/src/ImGui.NET/Generated/ImGuiSelectionBasicStorage.gen.cs
new file mode 100644
index 00000000..d929ff11
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiSelectionBasicStorage.gen.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiSelectionBasicStorage
+    {
+        public int Size;
+        public byte PreserveOrder;
+        public void* UserData;
+        public IntPtr AdapterIndexToStorageId;
+        public int _SelectionOrder;
+        public ImGuiStorage _Storage;
+    }
+    public unsafe partial struct ImGuiSelectionBasicStoragePtr
+    {
+        public ImGuiSelectionBasicStorage* NativePtr { get; }
+        public ImGuiSelectionBasicStoragePtr(ImGuiSelectionBasicStorage* nativePtr) => NativePtr = nativePtr;
+        public ImGuiSelectionBasicStoragePtr(IntPtr nativePtr) => NativePtr = (ImGuiSelectionBasicStorage*)nativePtr;
+        public static implicit operator ImGuiSelectionBasicStoragePtr(ImGuiSelectionBasicStorage* nativePtr) => new ImGuiSelectionBasicStoragePtr(nativePtr);
+        public static implicit operator ImGuiSelectionBasicStorage* (ImGuiSelectionBasicStoragePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiSelectionBasicStoragePtr(IntPtr nativePtr) => new ImGuiSelectionBasicStoragePtr(nativePtr);
+        public ref int Size => ref Unsafe.AsRef<int>(&NativePtr->Size);
+        public ref bool PreserveOrder => ref Unsafe.AsRef<bool>(&NativePtr->PreserveOrder);
+        public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
+        public ref IntPtr AdapterIndexToStorageId => ref Unsafe.AsRef<IntPtr>(&NativePtr->AdapterIndexToStorageId);
+        public ref int _SelectionOrder => ref Unsafe.AsRef<int>(&NativePtr->_SelectionOrder);
+        public ref ImGuiStorage _Storage => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->_Storage);
+        public void ApplyRequests(ImGuiMultiSelectIOPtr ms_io)
+        {
+            ImGuiMultiSelectIO* native_ms_io = ms_io.NativePtr;
+            ImGuiNative.ImGuiSelectionBasicStorage_ApplyRequests((ImGuiSelectionBasicStorage*)(NativePtr), native_ms_io);
+        }
+        public void Clear()
+        {
+            ImGuiNative.ImGuiSelectionBasicStorage_Clear((ImGuiSelectionBasicStorage*)(NativePtr));
+        }
+        public bool Contains(uint id)
+        {
+            byte ret = ImGuiNative.ImGuiSelectionBasicStorage_Contains((ImGuiSelectionBasicStorage*)(NativePtr), id);
+            return ret != 0;
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiSelectionBasicStorage_destroy((ImGuiSelectionBasicStorage*)(NativePtr));
+        }
+        public bool GetNextSelectedItem(ref void* opaque_it, out uint out_id)
+        {
+            fixed (void** native_opaque_it = &opaque_it)
+            {
+                fixed (uint* native_out_id = &out_id)
+                {
+                    byte ret = ImGuiNative.ImGuiSelectionBasicStorage_GetNextSelectedItem((ImGuiSelectionBasicStorage*)(NativePtr), native_opaque_it, native_out_id);
+                    return ret != 0;
+                }
+            }
+        }
+        public uint GetStorageIdFromIndex(int idx)
+        {
+            uint ret = ImGuiNative.ImGuiSelectionBasicStorage_GetStorageIdFromIndex((ImGuiSelectionBasicStorage*)(NativePtr), idx);
+            return ret;
+        }
+        public void SetItemSelected(uint id, bool selected)
+        {
+            byte native_selected = selected ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiSelectionBasicStorage_SetItemSelected((ImGuiSelectionBasicStorage*)(NativePtr), id, native_selected);
+        }
+        public void Swap(ImGuiSelectionBasicStoragePtr r)
+        {
+            ImGuiSelectionBasicStorage* native_r = r.NativePtr;
+            ImGuiNative.ImGuiSelectionBasicStorage_Swap((ImGuiSelectionBasicStorage*)(NativePtr), native_r);
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiSelectionExternalStorage.gen.cs b/src/ImGui.NET/Generated/ImGuiSelectionExternalStorage.gen.cs
new file mode 100644
index 00000000..fa8e2e02
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiSelectionExternalStorage.gen.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiSelectionExternalStorage
+    {
+        public void* UserData;
+        public IntPtr AdapterSetItemSelected;
+    }
+    public unsafe partial struct ImGuiSelectionExternalStoragePtr
+    {
+        public ImGuiSelectionExternalStorage* NativePtr { get; }
+        public ImGuiSelectionExternalStoragePtr(ImGuiSelectionExternalStorage* nativePtr) => NativePtr = nativePtr;
+        public ImGuiSelectionExternalStoragePtr(IntPtr nativePtr) => NativePtr = (ImGuiSelectionExternalStorage*)nativePtr;
+        public static implicit operator ImGuiSelectionExternalStoragePtr(ImGuiSelectionExternalStorage* nativePtr) => new ImGuiSelectionExternalStoragePtr(nativePtr);
+        public static implicit operator ImGuiSelectionExternalStorage* (ImGuiSelectionExternalStoragePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiSelectionExternalStoragePtr(IntPtr nativePtr) => new ImGuiSelectionExternalStoragePtr(nativePtr);
+        public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
+        public ref IntPtr AdapterSetItemSelected => ref Unsafe.AsRef<IntPtr>(&NativePtr->AdapterSetItemSelected);
+        public void ApplyRequests(ImGuiMultiSelectIOPtr ms_io)
+        {
+            ImGuiMultiSelectIO* native_ms_io = ms_io.NativePtr;
+            ImGuiNative.ImGuiSelectionExternalStorage_ApplyRequests((ImGuiSelectionExternalStorage*)(NativePtr), native_ms_io);
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiSelectionExternalStorage_destroy((ImGuiSelectionExternalStorage*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiSelectionRequest.gen.cs b/src/ImGui.NET/Generated/ImGuiSelectionRequest.gen.cs
new file mode 100644
index 00000000..86b52c0a
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiSelectionRequest.gen.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiSelectionRequest
+    {
+        public ImGuiSelectionRequestType Type;
+        public byte Selected;
+        public sbyte RangeDirection;
+        public long RangeFirstItem;
+        public long RangeLastItem;
+    }
+    public unsafe partial struct ImGuiSelectionRequestPtr
+    {
+        public ImGuiSelectionRequest* NativePtr { get; }
+        public ImGuiSelectionRequestPtr(ImGuiSelectionRequest* nativePtr) => NativePtr = nativePtr;
+        public ImGuiSelectionRequestPtr(IntPtr nativePtr) => NativePtr = (ImGuiSelectionRequest*)nativePtr;
+        public static implicit operator ImGuiSelectionRequestPtr(ImGuiSelectionRequest* nativePtr) => new ImGuiSelectionRequestPtr(nativePtr);
+        public static implicit operator ImGuiSelectionRequest* (ImGuiSelectionRequestPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiSelectionRequestPtr(IntPtr nativePtr) => new ImGuiSelectionRequestPtr(nativePtr);
+        public ref ImGuiSelectionRequestType Type => ref Unsafe.AsRef<ImGuiSelectionRequestType>(&NativePtr->Type);
+        public ref bool Selected => ref Unsafe.AsRef<bool>(&NativePtr->Selected);
+        public ref sbyte RangeDirection => ref Unsafe.AsRef<sbyte>(&NativePtr->RangeDirection);
+        public ref long RangeFirstItem => ref Unsafe.AsRef<long>(&NativePtr->RangeFirstItem);
+        public ref long RangeLastItem => ref Unsafe.AsRef<long>(&NativePtr->RangeLastItem);
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiSelectionRequestType.gen.cs b/src/ImGui.NET/Generated/ImGuiSelectionRequestType.gen.cs
new file mode 100644
index 00000000..45b2503a
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiSelectionRequestType.gen.cs
@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiSelectionRequestType
+    {
+        None = 0,
+        SetAll = 1,
+        SetRange = 2,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiSliderFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiSliderFlags.gen.cs
new file mode 100644
index 00000000..f080670d
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiSliderFlags.gen.cs
@@ -0,0 +1,16 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiSliderFlags
+    {
+        None = 0,
+        Logarithmic = 32,
+        NoRoundToFormat = 64,
+        NoInput = 128,
+        WrapAround = 256,
+        ClampOnInput = 512,
+        ClampZeroRange = 1024,
+        AlwaysClamp = 1536,
+        InvalidMask = 1879048207,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiSortDirection.gen.cs b/src/ImGui.NET/Generated/ImGuiSortDirection.gen.cs
new file mode 100644
index 00000000..7b4fae90
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiSortDirection.gen.cs
@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiSortDirection
+    {
+        None = 0,
+        Ascending = 1,
+        Descending = 2,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiStorage.gen.cs b/src/ImGui.NET/Generated/ImGuiStorage.gen.cs
index a65b7afa..7838589a 100644
--- a/src/ImGui.NET/Generated/ImGuiStorage.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiStorage.gen.cs
@@ -17,121 +17,121 @@ public unsafe partial struct ImGuiStoragePtr
         public static implicit operator ImGuiStoragePtr(ImGuiStorage* nativePtr) => new ImGuiStoragePtr(nativePtr);
         public static implicit operator ImGuiStorage* (ImGuiStoragePtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiStoragePtr(IntPtr nativePtr) => new ImGuiStoragePtr(nativePtr);
-        public ImVector<Pair> Data => new ImVector<Pair>(NativePtr->Data);
+        public ImPtrVector<ImGuiStoragePairPtr> Data => new ImPtrVector<ImGuiStoragePairPtr>(NativePtr->Data, Unsafe.SizeOf<ImGuiStoragePair>());
         public void BuildSortByKey()
         {
-            ImGuiNative.ImGuiStorage_BuildSortByKey(NativePtr);
+            ImGuiNative.ImGuiStorage_BuildSortByKey((ImGuiStorage*)(NativePtr));
         }
         public void Clear()
         {
-            ImGuiNative.ImGuiStorage_Clear(NativePtr);
+            ImGuiNative.ImGuiStorage_Clear((ImGuiStorage*)(NativePtr));
         }
         public bool GetBool(uint key)
         {
             byte default_val = 0;
-            byte ret = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val);
+            byte ret = ImGuiNative.ImGuiStorage_GetBool((ImGuiStorage*)(NativePtr), key, default_val);
             return ret != 0;
         }
         public bool GetBool(uint key, bool default_val)
         {
             byte native_default_val = default_val ? (byte)1 : (byte)0;
-            byte ret = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, native_default_val);
+            byte ret = ImGuiNative.ImGuiStorage_GetBool((ImGuiStorage*)(NativePtr), key, native_default_val);
             return ret != 0;
         }
         public byte* GetBoolRef(uint key)
         {
             byte default_val = 0;
-            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, default_val);
+            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public byte* GetBoolRef(uint key, bool default_val)
         {
             byte native_default_val = default_val ? (byte)1 : (byte)0;
-            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, native_default_val);
+            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef((ImGuiStorage*)(NativePtr), key, native_default_val);
             return ret;
         }
         public float GetFloat(uint key)
         {
             float default_val = 0.0f;
-            float ret = ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
+            float ret = ImGuiNative.ImGuiStorage_GetFloat((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public float GetFloat(uint key, float default_val)
         {
-            float ret = ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
+            float ret = ImGuiNative.ImGuiStorage_GetFloat((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public float* GetFloatRef(uint key)
         {
             float default_val = 0.0f;
-            float* ret = ImGuiNative.ImGuiStorage_GetFloatRef(NativePtr, key, default_val);
+            float* ret = ImGuiNative.ImGuiStorage_GetFloatRef((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public float* GetFloatRef(uint key, float default_val)
         {
-            float* ret = ImGuiNative.ImGuiStorage_GetFloatRef(NativePtr, key, default_val);
+            float* ret = ImGuiNative.ImGuiStorage_GetFloatRef((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public int GetInt(uint key)
         {
             int default_val = 0;
-            int ret = ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
+            int ret = ImGuiNative.ImGuiStorage_GetInt((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public int GetInt(uint key, int default_val)
         {
-            int ret = ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
+            int ret = ImGuiNative.ImGuiStorage_GetInt((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public int* GetIntRef(uint key)
         {
             int default_val = 0;
-            int* ret = ImGuiNative.ImGuiStorage_GetIntRef(NativePtr, key, default_val);
+            int* ret = ImGuiNative.ImGuiStorage_GetIntRef((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public int* GetIntRef(uint key, int default_val)
         {
-            int* ret = ImGuiNative.ImGuiStorage_GetIntRef(NativePtr, key, default_val);
+            int* ret = ImGuiNative.ImGuiStorage_GetIntRef((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public IntPtr GetVoidPtr(uint key)
         {
-            void* ret = ImGuiNative.ImGuiStorage_GetVoidPtr(NativePtr, key);
+            void* ret = ImGuiNative.ImGuiStorage_GetVoidPtr((ImGuiStorage*)(NativePtr), key);
             return (IntPtr)ret;
         }
         public void** GetVoidPtrRef(uint key)
         {
             void* default_val = null;
-            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, default_val);
+            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef((ImGuiStorage*)(NativePtr), key, default_val);
             return ret;
         }
         public void** GetVoidPtrRef(uint key, IntPtr default_val)
         {
             void* native_default_val = (void*)default_val.ToPointer();
-            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, native_default_val);
+            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef((ImGuiStorage*)(NativePtr), key, native_default_val);
             return ret;
         }
         public void SetAllInt(int val)
         {
-            ImGuiNative.ImGuiStorage_SetAllInt(NativePtr, val);
+            ImGuiNative.ImGuiStorage_SetAllInt((ImGuiStorage*)(NativePtr), val);
         }
         public void SetBool(uint key, bool val)
         {
             byte native_val = val ? (byte)1 : (byte)0;
-            ImGuiNative.ImGuiStorage_SetBool(NativePtr, key, native_val);
+            ImGuiNative.ImGuiStorage_SetBool((ImGuiStorage*)(NativePtr), key, native_val);
         }
         public void SetFloat(uint key, float val)
         {
-            ImGuiNative.ImGuiStorage_SetFloat(NativePtr, key, val);
+            ImGuiNative.ImGuiStorage_SetFloat((ImGuiStorage*)(NativePtr), key, val);
         }
         public void SetInt(uint key, int val)
         {
-            ImGuiNative.ImGuiStorage_SetInt(NativePtr, key, val);
+            ImGuiNative.ImGuiStorage_SetInt((ImGuiStorage*)(NativePtr), key, val);
         }
         public void SetVoidPtr(uint key, IntPtr val)
         {
             void* native_val = (void*)val.ToPointer();
-            ImGuiNative.ImGuiStorage_SetVoidPtr(NativePtr, key, native_val);
+            ImGuiNative.ImGuiStorage_SetVoidPtr((ImGuiStorage*)(NativePtr), key, native_val);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiStyle.gen.cs b/src/ImGui.NET/Generated/ImGuiStyle.gen.cs
index 69950d20..4a17ba36 100644
--- a/src/ImGui.NET/Generated/ImGuiStyle.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiStyle.gen.cs
@@ -8,11 +8,13 @@ namespace ImGuiNET
     public unsafe partial struct ImGuiStyle
     {
         public float Alpha;
+        public float DisabledAlpha;
         public Vector2 WindowPadding;
         public float WindowRounding;
         public float WindowBorderSize;
         public Vector2 WindowMinSize;
         public Vector2 WindowTitleAlign;
+        public ImGuiDir WindowMenuButtonPosition;
         public float ChildRounding;
         public float ChildBorderSize;
         public float PopupRounding;
@@ -22,6 +24,7 @@ public unsafe partial struct ImGuiStyle
         public float FrameBorderSize;
         public Vector2 ItemSpacing;
         public Vector2 ItemInnerSpacing;
+        public Vector2 CellPadding;
         public Vector2 TouchExtraPadding;
         public float IndentSpacing;
         public float ColumnsMinSpacing;
@@ -29,15 +32,29 @@ public unsafe partial struct ImGuiStyle
         public float ScrollbarRounding;
         public float GrabMinSize;
         public float GrabRounding;
+        public float LogSliderDeadzone;
         public float TabRounding;
         public float TabBorderSize;
+        public float TabMinWidthForCloseButton;
+        public float TabBarBorderSize;
+        public float TabBarOverlineSize;
+        public float TableAngledHeadersAngle;
+        public Vector2 TableAngledHeadersTextAlign;
+        public ImGuiDir ColorButtonPosition;
         public Vector2 ButtonTextAlign;
+        public Vector2 SelectableTextAlign;
+        public float SeparatorTextBorderSize;
+        public Vector2 SeparatorTextAlign;
+        public Vector2 SeparatorTextPadding;
         public Vector2 DisplayWindowPadding;
         public Vector2 DisplaySafeAreaPadding;
+        public float DockingSeparatorSize;
         public float MouseCursorScale;
         public byte AntiAliasedLines;
+        public byte AntiAliasedLinesUseTex;
         public byte AntiAliasedFill;
         public float CurveTessellationTol;
+        public float CircleTessellationMaxError;
         public Vector4 Colors_0;
         public Vector4 Colors_1;
         public Vector4 Colors_2;
@@ -86,6 +103,21 @@ public unsafe partial struct ImGuiStyle
         public Vector4 Colors_45;
         public Vector4 Colors_46;
         public Vector4 Colors_47;
+        public Vector4 Colors_48;
+        public Vector4 Colors_49;
+        public Vector4 Colors_50;
+        public Vector4 Colors_51;
+        public Vector4 Colors_52;
+        public Vector4 Colors_53;
+        public Vector4 Colors_54;
+        public Vector4 Colors_55;
+        public Vector4 Colors_56;
+        public Vector4 Colors_57;
+        public float HoverStationaryDelay;
+        public float HoverDelayShort;
+        public float HoverDelayNormal;
+        public ImGuiHoveredFlags HoverFlagsForTooltipMouse;
+        public ImGuiHoveredFlags HoverFlagsForTooltipNav;
     }
     public unsafe partial struct ImGuiStylePtr
     {
@@ -96,11 +128,13 @@ public unsafe partial struct ImGuiStylePtr
         public static implicit operator ImGuiStyle* (ImGuiStylePtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiStylePtr(IntPtr nativePtr) => new ImGuiStylePtr(nativePtr);
         public ref float Alpha => ref Unsafe.AsRef<float>(&NativePtr->Alpha);
+        public ref float DisabledAlpha => ref Unsafe.AsRef<float>(&NativePtr->DisabledAlpha);
         public ref Vector2 WindowPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowPadding);
         public ref float WindowRounding => ref Unsafe.AsRef<float>(&NativePtr->WindowRounding);
         public ref float WindowBorderSize => ref Unsafe.AsRef<float>(&NativePtr->WindowBorderSize);
         public ref Vector2 WindowMinSize => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowMinSize);
         public ref Vector2 WindowTitleAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowTitleAlign);
+        public ref ImGuiDir WindowMenuButtonPosition => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->WindowMenuButtonPosition);
         public ref float ChildRounding => ref Unsafe.AsRef<float>(&NativePtr->ChildRounding);
         public ref float ChildBorderSize => ref Unsafe.AsRef<float>(&NativePtr->ChildBorderSize);
         public ref float PopupRounding => ref Unsafe.AsRef<float>(&NativePtr->PopupRounding);
@@ -110,6 +144,7 @@ public unsafe partial struct ImGuiStylePtr
         public ref float FrameBorderSize => ref Unsafe.AsRef<float>(&NativePtr->FrameBorderSize);
         public ref Vector2 ItemSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->ItemSpacing);
         public ref Vector2 ItemInnerSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->ItemInnerSpacing);
+        public ref Vector2 CellPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->CellPadding);
         public ref Vector2 TouchExtraPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->TouchExtraPadding);
         public ref float IndentSpacing => ref Unsafe.AsRef<float>(&NativePtr->IndentSpacing);
         public ref float ColumnsMinSpacing => ref Unsafe.AsRef<float>(&NativePtr->ColumnsMinSpacing);
@@ -117,19 +152,42 @@ public unsafe partial struct ImGuiStylePtr
         public ref float ScrollbarRounding => ref Unsafe.AsRef<float>(&NativePtr->ScrollbarRounding);
         public ref float GrabMinSize => ref Unsafe.AsRef<float>(&NativePtr->GrabMinSize);
         public ref float GrabRounding => ref Unsafe.AsRef<float>(&NativePtr->GrabRounding);
+        public ref float LogSliderDeadzone => ref Unsafe.AsRef<float>(&NativePtr->LogSliderDeadzone);
         public ref float TabRounding => ref Unsafe.AsRef<float>(&NativePtr->TabRounding);
         public ref float TabBorderSize => ref Unsafe.AsRef<float>(&NativePtr->TabBorderSize);
+        public ref float TabMinWidthForCloseButton => ref Unsafe.AsRef<float>(&NativePtr->TabMinWidthForCloseButton);
+        public ref float TabBarBorderSize => ref Unsafe.AsRef<float>(&NativePtr->TabBarBorderSize);
+        public ref float TabBarOverlineSize => ref Unsafe.AsRef<float>(&NativePtr->TabBarOverlineSize);
+        public ref float TableAngledHeadersAngle => ref Unsafe.AsRef<float>(&NativePtr->TableAngledHeadersAngle);
+        public ref Vector2 TableAngledHeadersTextAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->TableAngledHeadersTextAlign);
+        public ref ImGuiDir ColorButtonPosition => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->ColorButtonPosition);
         public ref Vector2 ButtonTextAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->ButtonTextAlign);
+        public ref Vector2 SelectableTextAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->SelectableTextAlign);
+        public ref float SeparatorTextBorderSize => ref Unsafe.AsRef<float>(&NativePtr->SeparatorTextBorderSize);
+        public ref Vector2 SeparatorTextAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->SeparatorTextAlign);
+        public ref Vector2 SeparatorTextPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->SeparatorTextPadding);
         public ref Vector2 DisplayWindowPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayWindowPadding);
         public ref Vector2 DisplaySafeAreaPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySafeAreaPadding);
+        public ref float DockingSeparatorSize => ref Unsafe.AsRef<float>(&NativePtr->DockingSeparatorSize);
         public ref float MouseCursorScale => ref Unsafe.AsRef<float>(&NativePtr->MouseCursorScale);
         public ref bool AntiAliasedLines => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedLines);
+        public ref bool AntiAliasedLinesUseTex => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedLinesUseTex);
         public ref bool AntiAliasedFill => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedFill);
         public ref float CurveTessellationTol => ref Unsafe.AsRef<float>(&NativePtr->CurveTessellationTol);
-        public RangeAccessor<Vector4> Colors => new RangeAccessor<Vector4>(&NativePtr->Colors_0, 48);
+        public ref float CircleTessellationMaxError => ref Unsafe.AsRef<float>(&NativePtr->CircleTessellationMaxError);
+        public RangeAccessor<Vector4> Colors => new RangeAccessor<Vector4>(&NativePtr->Colors_0, 58);
+        public ref float HoverStationaryDelay => ref Unsafe.AsRef<float>(&NativePtr->HoverStationaryDelay);
+        public ref float HoverDelayShort => ref Unsafe.AsRef<float>(&NativePtr->HoverDelayShort);
+        public ref float HoverDelayNormal => ref Unsafe.AsRef<float>(&NativePtr->HoverDelayNormal);
+        public ref ImGuiHoveredFlags HoverFlagsForTooltipMouse => ref Unsafe.AsRef<ImGuiHoveredFlags>(&NativePtr->HoverFlagsForTooltipMouse);
+        public ref ImGuiHoveredFlags HoverFlagsForTooltipNav => ref Unsafe.AsRef<ImGuiHoveredFlags>(&NativePtr->HoverFlagsForTooltipNav);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiStyle_destroy((ImGuiStyle*)(NativePtr));
+        }
         public void ScaleAllSizes(float scale_factor)
         {
-            ImGuiNative.ImGuiStyle_ScaleAllSizes(NativePtr, scale_factor);
+            ImGuiNative.ImGuiStyle_ScaleAllSizes((ImGuiStyle*)(NativePtr), scale_factor);
         }
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiStyleVar.gen.cs b/src/ImGui.NET/Generated/ImGuiStyleVar.gen.cs
index 890ab984..7434bb3d 100644
--- a/src/ImGui.NET/Generated/ImGuiStyleVar.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiStyleVar.gen.cs
@@ -3,27 +3,39 @@ namespace ImGuiNET
     public enum ImGuiStyleVar
     {
         Alpha = 0,
-        WindowPadding = 1,
-        WindowRounding = 2,
-        WindowBorderSize = 3,
-        WindowMinSize = 4,
-        WindowTitleAlign = 5,
-        ChildRounding = 6,
-        ChildBorderSize = 7,
-        PopupRounding = 8,
-        PopupBorderSize = 9,
-        FramePadding = 10,
-        FrameRounding = 11,
-        FrameBorderSize = 12,
-        ItemSpacing = 13,
-        ItemInnerSpacing = 14,
-        IndentSpacing = 15,
-        ScrollbarSize = 16,
-        ScrollbarRounding = 17,
-        GrabMinSize = 18,
-        GrabRounding = 19,
-        TabRounding = 20,
-        ButtonTextAlign = 21,
-        COUNT = 22,
+        DisabledAlpha = 1,
+        WindowPadding = 2,
+        WindowRounding = 3,
+        WindowBorderSize = 4,
+        WindowMinSize = 5,
+        WindowTitleAlign = 6,
+        ChildRounding = 7,
+        ChildBorderSize = 8,
+        PopupRounding = 9,
+        PopupBorderSize = 10,
+        FramePadding = 11,
+        FrameRounding = 12,
+        FrameBorderSize = 13,
+        ItemSpacing = 14,
+        ItemInnerSpacing = 15,
+        IndentSpacing = 16,
+        CellPadding = 17,
+        ScrollbarSize = 18,
+        ScrollbarRounding = 19,
+        GrabMinSize = 20,
+        GrabRounding = 21,
+        TabRounding = 22,
+        TabBorderSize = 23,
+        TabBarBorderSize = 24,
+        TabBarOverlineSize = 25,
+        TableAngledHeadersAngle = 26,
+        TableAngledHeadersTextAlign = 27,
+        ButtonTextAlign = 28,
+        SelectableTextAlign = 29,
+        SeparatorTextBorderSize = 30,
+        SeparatorTextAlign = 31,
+        SeparatorTextPadding = 32,
+        DockingSeparatorSize = 33,
+        COUNT = 34,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiTabBarFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiTabBarFlags.gen.cs
index dcd43535..77d90ca3 100644
--- a/src/ImGui.NET/Generated/ImGuiTabBarFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiTabBarFlags.gen.cs
@@ -4,15 +4,16 @@ namespace ImGuiNET
     public enum ImGuiTabBarFlags
     {
         None = 0,
-        Reorderable = 1 << 0,
-        AutoSelectNewTabs = 1 << 1,
-        NoCloseWithMiddleMouseButton = 1 << 2,
-        NoTabListPopupButton = 1 << 3,
-        NoTabListScrollingButtons = 1 << 4,
-        NoTooltip = 1 << 5,
-        FittingPolicyResizeDown = 1 << 6,
-        FittingPolicyScroll = 1 << 7,
-        FittingPolicyMask = FittingPolicyResizeDown | FittingPolicyScroll,
-        FittingPolicyDefault = FittingPolicyResizeDown,
+        Reorderable = 1,
+        AutoSelectNewTabs = 2,
+        TabListPopupButton = 4,
+        NoCloseWithMiddleMouseButton = 8,
+        NoTabListScrollingButtons = 16,
+        NoTooltip = 32,
+        DrawSelectedOverline = 64,
+        FittingPolicyResizeDown = 128,
+        FittingPolicyScroll = 256,
+        FittingPolicyMask = 384,
+        FittingPolicyDefault = 128,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiTabItemFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiTabItemFlags.gen.cs
index 963b4cd2..5f723698 100644
--- a/src/ImGui.NET/Generated/ImGuiTabItemFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiTabItemFlags.gen.cs
@@ -4,9 +4,14 @@ namespace ImGuiNET
     public enum ImGuiTabItemFlags
     {
         None = 0,
-        UnsavedDocument = 1 << 0,
-        SetSelected = 1 << 1,
-        NoCloseWithMiddleMouseButton = 1 << 2,
-        NoPushId = 1 << 3,
+        UnsavedDocument = 1,
+        SetSelected = 2,
+        NoCloseWithMiddleMouseButton = 4,
+        NoPushId = 8,
+        NoTooltip = 16,
+        NoReorder = 32,
+        Leading = 64,
+        Trailing = 128,
+        NoAssumedClosure = 256,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiTableBgTarget.gen.cs b/src/ImGui.NET/Generated/ImGuiTableBgTarget.gen.cs
new file mode 100644
index 00000000..83a11021
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTableBgTarget.gen.cs
@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    public enum ImGuiTableBgTarget
+    {
+        None = 0,
+        RowBg0 = 1,
+        RowBg1 = 2,
+        CellBg = 3,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTableColumnFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiTableColumnFlags.gen.cs
new file mode 100644
index 00000000..cdeb4f56
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTableColumnFlags.gen.cs
@@ -0,0 +1,35 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTableColumnFlags
+    {
+        None = 0,
+        Disabled = 1,
+        DefaultHide = 2,
+        DefaultSort = 4,
+        WidthStretch = 8,
+        WidthFixed = 16,
+        NoResize = 32,
+        NoReorder = 64,
+        NoHide = 128,
+        NoClip = 256,
+        NoSort = 512,
+        NoSortAscending = 1024,
+        NoSortDescending = 2048,
+        NoHeaderLabel = 4096,
+        NoHeaderWidth = 8192,
+        PreferSortAscending = 16384,
+        PreferSortDescending = 32768,
+        IndentEnable = 65536,
+        IndentDisable = 131072,
+        AngledHeader = 262144,
+        IsEnabled = 16777216,
+        IsVisible = 33554432,
+        IsSorted = 67108864,
+        IsHovered = 134217728,
+        WidthMask = 24,
+        IndentMask = 196608,
+        StatusMask = 251658240,
+        NoDirectResize = 1073741824,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTableColumnSortSpecs.gen.cs b/src/ImGui.NET/Generated/ImGuiTableColumnSortSpecs.gen.cs
new file mode 100644
index 00000000..ef1d61bd
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTableColumnSortSpecs.gen.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiTableColumnSortSpecs
+    {
+        public uint ColumnUserID;
+        public short ColumnIndex;
+        public short SortOrder;
+        public ImGuiSortDirection SortDirection;
+    }
+    public unsafe partial struct ImGuiTableColumnSortSpecsPtr
+    {
+        public ImGuiTableColumnSortSpecs* NativePtr { get; }
+        public ImGuiTableColumnSortSpecsPtr(ImGuiTableColumnSortSpecs* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableColumnSortSpecsPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableColumnSortSpecs*)nativePtr;
+        public static implicit operator ImGuiTableColumnSortSpecsPtr(ImGuiTableColumnSortSpecs* nativePtr) => new ImGuiTableColumnSortSpecsPtr(nativePtr);
+        public static implicit operator ImGuiTableColumnSortSpecs* (ImGuiTableColumnSortSpecsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableColumnSortSpecsPtr(IntPtr nativePtr) => new ImGuiTableColumnSortSpecsPtr(nativePtr);
+        public ref uint ColumnUserID => ref Unsafe.AsRef<uint>(&NativePtr->ColumnUserID);
+        public ref short ColumnIndex => ref Unsafe.AsRef<short>(&NativePtr->ColumnIndex);
+        public ref short SortOrder => ref Unsafe.AsRef<short>(&NativePtr->SortOrder);
+        public ref ImGuiSortDirection SortDirection => ref Unsafe.AsRef<ImGuiSortDirection>(&NativePtr->SortDirection);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableColumnSortSpecs_destroy((ImGuiTableColumnSortSpecs*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTableFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiTableFlags.gen.cs
new file mode 100644
index 00000000..715caff8
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTableFlags.gen.cs
@@ -0,0 +1,44 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTableFlags
+    {
+        None = 0,
+        Resizable = 1,
+        Reorderable = 2,
+        Hideable = 4,
+        Sortable = 8,
+        NoSavedSettings = 16,
+        ContextMenuInBody = 32,
+        RowBg = 64,
+        BordersInnerH = 128,
+        BordersOuterH = 256,
+        BordersInnerV = 512,
+        BordersOuterV = 1024,
+        BordersH = 384,
+        BordersV = 1536,
+        BordersInner = 640,
+        BordersOuter = 1280,
+        Borders = 1920,
+        NoBordersInBody = 2048,
+        NoBordersInBodyUntilResize = 4096,
+        SizingFixedFit = 8192,
+        SizingFixedSame = 16384,
+        SizingStretchProp = 24576,
+        SizingStretchSame = 32768,
+        NoHostExtendX = 65536,
+        NoHostExtendY = 131072,
+        NoKeepColumnsVisible = 262144,
+        PreciseWidths = 524288,
+        NoClip = 1048576,
+        PadOuterX = 2097152,
+        NoPadOuterX = 4194304,
+        NoPadInnerX = 8388608,
+        ScrollX = 16777216,
+        ScrollY = 33554432,
+        SortMulti = 67108864,
+        SortTristate = 134217728,
+        HighlightHoveredColumn = 268435456,
+        SizingMask = 57344,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTableRowFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiTableRowFlags.gen.cs
new file mode 100644
index 00000000..e90a011f
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTableRowFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTableRowFlags
+    {
+        None = 0,
+        Headers = 1,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTableSortSpecs.gen.cs b/src/ImGui.NET/Generated/ImGuiTableSortSpecs.gen.cs
new file mode 100644
index 00000000..626eeeff
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTableSortSpecs.gen.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiTableSortSpecs
+    {
+        public ImGuiTableColumnSortSpecs* Specs;
+        public int SpecsCount;
+        public byte SpecsDirty;
+    }
+    public unsafe partial struct ImGuiTableSortSpecsPtr
+    {
+        public ImGuiTableSortSpecs* NativePtr { get; }
+        public ImGuiTableSortSpecsPtr(ImGuiTableSortSpecs* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableSortSpecsPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableSortSpecs*)nativePtr;
+        public static implicit operator ImGuiTableSortSpecsPtr(ImGuiTableSortSpecs* nativePtr) => new ImGuiTableSortSpecsPtr(nativePtr);
+        public static implicit operator ImGuiTableSortSpecs* (ImGuiTableSortSpecsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableSortSpecsPtr(IntPtr nativePtr) => new ImGuiTableSortSpecsPtr(nativePtr);
+        public ImGuiTableColumnSortSpecsPtr Specs => new ImGuiTableColumnSortSpecsPtr(NativePtr->Specs);
+        public ref int SpecsCount => ref Unsafe.AsRef<int>(&NativePtr->SpecsCount);
+        public ref bool SpecsDirty => ref Unsafe.AsRef<bool>(&NativePtr->SpecsDirty);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableSortSpecs_destroy((ImGuiTableSortSpecs*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTextBuffer.gen.cs b/src/ImGui.NET/Generated/ImGuiTextBuffer.gen.cs
index 9215d982..7c3db2f6 100644
--- a/src/ImGui.NET/Generated/ImGuiTextBuffer.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiTextBuffer.gen.cs
@@ -18,7 +18,92 @@ public unsafe partial struct ImGuiTextBufferPtr
         public static implicit operator ImGuiTextBuffer* (ImGuiTextBufferPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiTextBufferPtr(IntPtr nativePtr) => new ImGuiTextBufferPtr(nativePtr);
         public ImVector<byte> Buf => new ImVector<byte>(NativePtr->Buf);
-        public void appendf(string fmt)
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void append(ReadOnlySpan<char> str)
+        {
+            byte* native_str;
+            int str_byteCount = 0;
+            if (str != null)
+            {
+                str_byteCount = Encoding.UTF8.GetByteCount(str);
+                if (str_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str = Util.Allocate(str_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_stackBytes = stackalloc byte[str_byteCount + 1];
+                    native_str = native_str_stackBytes;
+                }
+                int native_str_offset = Util.GetUtf8(str, native_str, str_byteCount);
+                native_str[native_str_offset] = 0;
+            }
+            else { native_str = null; }
+            ImGuiNative.ImGuiTextBuffer_append((ImGuiTextBuffer*)(NativePtr), native_str, native_str+str_byteCount);
+            if (str_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str);
+            }
+        }
+#endif
+        public void append(string str)
+        {
+            byte* native_str;
+            int str_byteCount = 0;
+            if (str != null)
+            {
+                str_byteCount = Encoding.UTF8.GetByteCount(str);
+                if (str_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str = Util.Allocate(str_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_stackBytes = stackalloc byte[str_byteCount + 1];
+                    native_str = native_str_stackBytes;
+                }
+                int native_str_offset = Util.GetUtf8(str, native_str, str_byteCount);
+                native_str[native_str_offset] = 0;
+            }
+            else { native_str = null; }
+            ImGuiNative.ImGuiTextBuffer_append((ImGuiTextBuffer*)(NativePtr), native_str, native_str+str_byteCount);
+            if (str_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public void appendf(ref ImGuiTextBuffer buffer, ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            fixed (ImGuiTextBuffer* native_buffer = &buffer)
+            {
+                ImGuiNative.ImGuiTextBuffer_appendf(native_buffer, native_fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_fmt);
+                }
+            }
+        }
+#endif
+        public void appendf(ref ImGuiTextBuffer buffer, string fmt)
         {
             byte* native_fmt;
             int fmt_byteCount = 0;
@@ -38,43 +123,50 @@ public void appendf(string fmt)
                 native_fmt[native_fmt_offset] = 0;
             }
             else { native_fmt = null; }
-            ImGuiNative.ImGuiTextBuffer_appendf(NativePtr, native_fmt);
-            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            fixed (ImGuiTextBuffer* native_buffer = &buffer)
             {
-                Util.Free(native_fmt);
+                ImGuiNative.ImGuiTextBuffer_appendf(native_buffer, native_fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_fmt);
+                }
             }
         }
         public string begin()
         {
-            byte* ret = ImGuiNative.ImGuiTextBuffer_begin(NativePtr);
+            byte* ret = ImGuiNative.ImGuiTextBuffer_begin((ImGuiTextBuffer*)(NativePtr));
             return Util.StringFromPtr(ret);
         }
         public string c_str()
         {
-            byte* ret = ImGuiNative.ImGuiTextBuffer_c_str(NativePtr);
+            byte* ret = ImGuiNative.ImGuiTextBuffer_c_str((ImGuiTextBuffer*)(NativePtr));
             return Util.StringFromPtr(ret);
         }
         public void clear()
         {
-            ImGuiNative.ImGuiTextBuffer_clear(NativePtr);
+            ImGuiNative.ImGuiTextBuffer_clear((ImGuiTextBuffer*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTextBuffer_destroy((ImGuiTextBuffer*)(NativePtr));
         }
         public bool empty()
         {
-            byte ret = ImGuiNative.ImGuiTextBuffer_empty(NativePtr);
+            byte ret = ImGuiNative.ImGuiTextBuffer_empty((ImGuiTextBuffer*)(NativePtr));
             return ret != 0;
         }
         public string end()
         {
-            byte* ret = ImGuiNative.ImGuiTextBuffer_end(NativePtr);
+            byte* ret = ImGuiNative.ImGuiTextBuffer_end((ImGuiTextBuffer*)(NativePtr));
             return Util.StringFromPtr(ret);
         }
         public void reserve(int capacity)
         {
-            ImGuiNative.ImGuiTextBuffer_reserve(NativePtr, capacity);
+            ImGuiNative.ImGuiTextBuffer_reserve((ImGuiTextBuffer*)(NativePtr), capacity);
         }
         public int size()
         {
-            int ret = ImGuiNative.ImGuiTextBuffer_size(NativePtr);
+            int ret = ImGuiNative.ImGuiTextBuffer_size((ImGuiTextBuffer*)(NativePtr));
             return ret;
         }
     }
diff --git a/src/ImGui.NET/Generated/ImGuiTextFilter.gen.cs b/src/ImGui.NET/Generated/ImGuiTextFilter.gen.cs
index 8b00332e..e8dff5fb 100644
--- a/src/ImGui.NET/Generated/ImGuiTextFilter.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiTextFilter.gen.cs
@@ -20,15 +20,19 @@ public unsafe partial struct ImGuiTextFilterPtr
         public static implicit operator ImGuiTextFilter* (ImGuiTextFilterPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiTextFilterPtr(IntPtr nativePtr) => new ImGuiTextFilterPtr(nativePtr);
         public RangeAccessor<byte> InputBuf => new RangeAccessor<byte>(NativePtr->InputBuf, 256);
-        public ImVector<TextRange> Filters => new ImVector<TextRange>(NativePtr->Filters);
+        public ImPtrVector<ImGuiTextRangePtr> Filters => new ImPtrVector<ImGuiTextRangePtr>(NativePtr->Filters, Unsafe.SizeOf<ImGuiTextRange>());
         public ref int CountGrep => ref Unsafe.AsRef<int>(&NativePtr->CountGrep);
         public void Build()
         {
-            ImGuiNative.ImGuiTextFilter_Build(NativePtr);
+            ImGuiNative.ImGuiTextFilter_Build((ImGuiTextFilter*)(NativePtr));
         }
         public void Clear()
         {
-            ImGuiNative.ImGuiTextFilter_Clear(NativePtr);
+            ImGuiNative.ImGuiTextFilter_Clear((ImGuiTextFilter*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTextFilter_destroy((ImGuiTextFilter*)(NativePtr));
         }
         public bool Draw()
         {
@@ -47,13 +51,43 @@ public bool Draw()
                 int native_label_offset = Util.GetUtf8("Filter(inc,-exc)", native_label, label_byteCount);
                 native_label[native_label_offset] = 0;
             float width = 0.0f;
-            byte ret = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, native_label, width);
+            byte ret = ImGuiNative.ImGuiTextFilter_Draw((ImGuiTextFilter*)(NativePtr), native_label, width);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public bool Draw(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            float width = 0.0f;
+            byte ret = ImGuiNative.ImGuiTextFilter_Draw((ImGuiTextFilter*)(NativePtr), native_label, width);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
         public bool Draw(string label)
         {
             byte* native_label;
@@ -75,13 +109,42 @@ public bool Draw(string label)
             }
             else { native_label = null; }
             float width = 0.0f;
-            byte ret = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, native_label, width);
+            byte ret = ImGuiNative.ImGuiTextFilter_Draw((ImGuiTextFilter*)(NativePtr), native_label, width);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public bool Draw(ReadOnlySpan<char> label, float width)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImGuiNative.ImGuiTextFilter_Draw((ImGuiTextFilter*)(NativePtr), native_label, width);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
             }
             return ret != 0;
         }
+#endif
         public bool Draw(string label, float width)
         {
             byte* native_label;
@@ -102,7 +165,7 @@ public bool Draw(string label, float width)
                 native_label[native_label_offset] = 0;
             }
             else { native_label = null; }
-            byte ret = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, native_label, width);
+            byte ret = ImGuiNative.ImGuiTextFilter_Draw((ImGuiTextFilter*)(NativePtr), native_label, width);
             if (label_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_label);
@@ -111,9 +174,38 @@ public bool Draw(string label, float width)
         }
         public bool IsActive()
         {
-            byte ret = ImGuiNative.ImGuiTextFilter_IsActive(NativePtr);
+            byte ret = ImGuiNative.ImGuiTextFilter_IsActive((ImGuiTextFilter*)(NativePtr));
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public bool PassFilter(ReadOnlySpan<char> text)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            byte ret = ImGuiNative.ImGuiTextFilter_PassFilter((ImGuiTextFilter*)(NativePtr), native_text, native_text+text_byteCount);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
             return ret != 0;
         }
+#endif
         public bool PassFilter(string text)
         {
             byte* native_text;
@@ -134,8 +226,7 @@ public bool PassFilter(string text)
                 native_text[native_text_offset] = 0;
             }
             else { native_text = null; }
-            byte* native_text_end = null;
-            byte ret = ImGuiNative.ImGuiTextFilter_PassFilter(NativePtr, native_text, native_text_end);
+            byte ret = ImGuiNative.ImGuiTextFilter_PassFilter((ImGuiTextFilter*)(NativePtr), native_text, native_text+text_byteCount);
             if (text_byteCount > Util.StackAllocationSizeLimit)
             {
                 Util.Free(native_text);
diff --git a/src/ImGui.NET/Generated/ImGuiTextRange.gen.cs b/src/ImGui.NET/Generated/ImGuiTextRange.gen.cs
new file mode 100644
index 00000000..1f00fd67
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiTextRange.gen.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiTextRange
+    {
+        public byte* b;
+        public byte* e;
+    }
+    public unsafe partial struct ImGuiTextRangePtr
+    {
+        public ImGuiTextRange* NativePtr { get; }
+        public ImGuiTextRangePtr(ImGuiTextRange* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTextRangePtr(IntPtr nativePtr) => NativePtr = (ImGuiTextRange*)nativePtr;
+        public static implicit operator ImGuiTextRangePtr(ImGuiTextRange* nativePtr) => new ImGuiTextRangePtr(nativePtr);
+        public static implicit operator ImGuiTextRange* (ImGuiTextRangePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTextRangePtr(IntPtr nativePtr) => new ImGuiTextRangePtr(nativePtr);
+        public IntPtr b { get => (IntPtr)NativePtr->b; set => NativePtr->b = (byte*)value; }
+        public IntPtr e { get => (IntPtr)NativePtr->e; set => NativePtr->e = (byte*)value; }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTextRange_destroy((ImGuiTextRange*)(NativePtr));
+        }
+        public bool empty()
+        {
+            byte ret = ImGuiNative.ImGuiTextRange_empty((ImGuiTextRange*)(NativePtr));
+            return ret != 0;
+        }
+        public void split(byte separator, out ImVector @out)
+        {
+            fixed (ImVector* native_out = &@out)
+            {
+                ImGuiNative.ImGuiTextRange_split((ImGuiTextRange*)(NativePtr), separator, native_out);
+            }
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiTreeNodeFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiTreeNodeFlags.gen.cs
index cd9d4926..88dd8bd8 100644
--- a/src/ImGui.NET/Generated/ImGuiTreeNodeFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiTreeNodeFlags.gen.cs
@@ -4,18 +4,22 @@ namespace ImGuiNET
     public enum ImGuiTreeNodeFlags
     {
         None = 0,
-        Selected = 1 << 0,
-        Framed = 1 << 1,
-        AllowItemOverlap = 1 << 2,
-        NoTreePushOnOpen = 1 << 3,
-        NoAutoOpenOnLog = 1 << 4,
-        DefaultOpen = 1 << 5,
-        OpenOnDoubleClick = 1 << 6,
-        OpenOnArrow = 1 << 7,
-        Leaf = 1 << 8,
-        Bullet = 1 << 9,
-        FramePadding = 1 << 10,
-        NavLeftJumpsBackHere = 1 << 13,
-        CollapsingHeader = Framed | NoTreePushOnOpen | NoAutoOpenOnLog,
+        Selected = 1,
+        Framed = 2,
+        AllowOverlap = 4,
+        NoTreePushOnOpen = 8,
+        NoAutoOpenOnLog = 16,
+        DefaultOpen = 32,
+        OpenOnDoubleClick = 64,
+        OpenOnArrow = 128,
+        Leaf = 256,
+        Bullet = 512,
+        FramePadding = 1024,
+        SpanAvailWidth = 2048,
+        SpanFullWidth = 4096,
+        SpanTextWidth = 8192,
+        SpanAllColumns = 16384,
+        NavLeftJumpsBackHere = 32768,
+        CollapsingHeader = 26,
     }
 }
diff --git a/src/ImGui.NET/Generated/ImGuiViewport.gen.cs b/src/ImGui.NET/Generated/ImGuiViewport.gen.cs
new file mode 100644
index 00000000..1f57aa45
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiViewport.gen.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiViewport
+    {
+        public uint ID;
+        public ImGuiViewportFlags Flags;
+        public Vector2 Pos;
+        public Vector2 Size;
+        public Vector2 WorkPos;
+        public Vector2 WorkSize;
+        public float DpiScale;
+        public uint ParentViewportId;
+        public ImDrawData* DrawData;
+        public void* RendererUserData;
+        public void* PlatformUserData;
+        public void* PlatformHandle;
+        public void* PlatformHandleRaw;
+        public byte PlatformWindowCreated;
+        public byte PlatformRequestMove;
+        public byte PlatformRequestResize;
+        public byte PlatformRequestClose;
+    }
+    public unsafe partial struct ImGuiViewportPtr
+    {
+        public ImGuiViewport* NativePtr { get; }
+        public ImGuiViewportPtr(ImGuiViewport* nativePtr) => NativePtr = nativePtr;
+        public ImGuiViewportPtr(IntPtr nativePtr) => NativePtr = (ImGuiViewport*)nativePtr;
+        public static implicit operator ImGuiViewportPtr(ImGuiViewport* nativePtr) => new ImGuiViewportPtr(nativePtr);
+        public static implicit operator ImGuiViewport* (ImGuiViewportPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiViewportPtr(IntPtr nativePtr) => new ImGuiViewportPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiViewportFlags Flags => ref Unsafe.AsRef<ImGuiViewportFlags>(&NativePtr->Flags);
+        public ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos);
+        public ref Vector2 Size => ref Unsafe.AsRef<Vector2>(&NativePtr->Size);
+        public ref Vector2 WorkPos => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkPos);
+        public ref Vector2 WorkSize => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkSize);
+        public ref float DpiScale => ref Unsafe.AsRef<float>(&NativePtr->DpiScale);
+        public ref uint ParentViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ParentViewportId);
+        public ImDrawDataPtr DrawData => new ImDrawDataPtr(NativePtr->DrawData);
+        public IntPtr RendererUserData { get => (IntPtr)NativePtr->RendererUserData; set => NativePtr->RendererUserData = (void*)value; }
+        public IntPtr PlatformUserData { get => (IntPtr)NativePtr->PlatformUserData; set => NativePtr->PlatformUserData = (void*)value; }
+        public IntPtr PlatformHandle { get => (IntPtr)NativePtr->PlatformHandle; set => NativePtr->PlatformHandle = (void*)value; }
+        public IntPtr PlatformHandleRaw { get => (IntPtr)NativePtr->PlatformHandleRaw; set => NativePtr->PlatformHandleRaw = (void*)value; }
+        public ref bool PlatformWindowCreated => ref Unsafe.AsRef<bool>(&NativePtr->PlatformWindowCreated);
+        public ref bool PlatformRequestMove => ref Unsafe.AsRef<bool>(&NativePtr->PlatformRequestMove);
+        public ref bool PlatformRequestResize => ref Unsafe.AsRef<bool>(&NativePtr->PlatformRequestResize);
+        public ref bool PlatformRequestClose => ref Unsafe.AsRef<bool>(&NativePtr->PlatformRequestClose);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiViewport_destroy((ImGuiViewport*)(NativePtr));
+        }
+        public Vector2 GetCenter()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImGuiViewport_GetCenter(&__retval, (ImGuiViewport*)(NativePtr));
+            return __retval;
+        }
+        public Vector2 GetWorkCenter()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImGuiViewport_GetWorkCenter(&__retval, (ImGuiViewport*)(NativePtr));
+            return __retval;
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiViewportFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiViewportFlags.gen.cs
new file mode 100644
index 00000000..720967f1
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiViewportFlags.gen.cs
@@ -0,0 +1,22 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiViewportFlags
+    {
+        None = 0,
+        IsPlatformWindow = 1,
+        IsPlatformMonitor = 2,
+        OwnedByApp = 4,
+        NoDecoration = 8,
+        NoTaskBarIcon = 16,
+        NoFocusOnAppearing = 32,
+        NoFocusOnClick = 64,
+        NoInputs = 128,
+        NoRendererClear = 256,
+        NoAutoMerge = 512,
+        TopMost = 1024,
+        CanHostOtherWindows = 2048,
+        IsMinimized = 4096,
+        IsFocused = 8192,
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiWindowClass.gen.cs b/src/ImGui.NET/Generated/ImGuiWindowClass.gen.cs
new file mode 100644
index 00000000..e4defab3
--- /dev/null
+++ b/src/ImGui.NET/Generated/ImGuiWindowClass.gen.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct ImGuiWindowClass
+    {
+        public uint ClassId;
+        public uint ParentViewportId;
+        public uint FocusRouteParentWindowId;
+        public ImGuiViewportFlags ViewportFlagsOverrideSet;
+        public ImGuiViewportFlags ViewportFlagsOverrideClear;
+        public ImGuiTabItemFlags TabItemFlagsOverrideSet;
+        public ImGuiDockNodeFlags DockNodeFlagsOverrideSet;
+        public byte DockingAlwaysTabBar;
+        public byte DockingAllowUnclassed;
+    }
+    public unsafe partial struct ImGuiWindowClassPtr
+    {
+        public ImGuiWindowClass* NativePtr { get; }
+        public ImGuiWindowClassPtr(ImGuiWindowClass* nativePtr) => NativePtr = nativePtr;
+        public ImGuiWindowClassPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowClass*)nativePtr;
+        public static implicit operator ImGuiWindowClassPtr(ImGuiWindowClass* nativePtr) => new ImGuiWindowClassPtr(nativePtr);
+        public static implicit operator ImGuiWindowClass* (ImGuiWindowClassPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiWindowClassPtr(IntPtr nativePtr) => new ImGuiWindowClassPtr(nativePtr);
+        public ref uint ClassId => ref Unsafe.AsRef<uint>(&NativePtr->ClassId);
+        public ref uint ParentViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ParentViewportId);
+        public ref uint FocusRouteParentWindowId => ref Unsafe.AsRef<uint>(&NativePtr->FocusRouteParentWindowId);
+        public ref ImGuiViewportFlags ViewportFlagsOverrideSet => ref Unsafe.AsRef<ImGuiViewportFlags>(&NativePtr->ViewportFlagsOverrideSet);
+        public ref ImGuiViewportFlags ViewportFlagsOverrideClear => ref Unsafe.AsRef<ImGuiViewportFlags>(&NativePtr->ViewportFlagsOverrideClear);
+        public ref ImGuiTabItemFlags TabItemFlagsOverrideSet => ref Unsafe.AsRef<ImGuiTabItemFlags>(&NativePtr->TabItemFlagsOverrideSet);
+        public ref ImGuiDockNodeFlags DockNodeFlagsOverrideSet => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->DockNodeFlagsOverrideSet);
+        public ref bool DockingAlwaysTabBar => ref Unsafe.AsRef<bool>(&NativePtr->DockingAlwaysTabBar);
+        public ref bool DockingAllowUnclassed => ref Unsafe.AsRef<bool>(&NativePtr->DockingAllowUnclassed);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiWindowClass_destroy((ImGuiWindowClass*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImGui.NET/Generated/ImGuiWindowFlags.gen.cs b/src/ImGui.NET/Generated/ImGuiWindowFlags.gen.cs
index 43e13907..184f40de 100644
--- a/src/ImGui.NET/Generated/ImGuiWindowFlags.gen.cs
+++ b/src/ImGui.NET/Generated/ImGuiWindowFlags.gen.cs
@@ -4,34 +4,34 @@ namespace ImGuiNET
     public enum ImGuiWindowFlags
     {
         None = 0,
-        NoTitleBar = 1 << 0,
-        NoResize = 1 << 1,
-        NoMove = 1 << 2,
-        NoScrollbar = 1 << 3,
-        NoScrollWithMouse = 1 << 4,
-        NoCollapse = 1 << 5,
-        AlwaysAutoResize = 1 << 6,
-        NoBackground = 1 << 7,
-        NoSavedSettings = 1 << 8,
-        NoMouseInputs = 1 << 9,
-        MenuBar = 1 << 10,
-        HorizontalScrollbar = 1 << 11,
-        NoFocusOnAppearing = 1 << 12,
-        NoBringToFrontOnFocus = 1 << 13,
-        AlwaysVerticalScrollbar = 1 << 14,
-        AlwaysHorizontalScrollbar = 1<< 15,
-        AlwaysUseWindowPadding = 1 << 16,
-        NoNavInputs = 1 << 18,
-        NoNavFocus = 1 << 19,
-        UnsavedDocument = 1 << 20,
-        NoNav = NoNavInputs | NoNavFocus,
-        NoDecoration = NoTitleBar | NoResize | NoScrollbar | NoCollapse,
-        NoInputs = NoMouseInputs | NoNavInputs | NoNavFocus,
-        NavFlattened = 1 << 23,
-        ChildWindow = 1 << 24,
-        Tooltip = 1 << 25,
-        Popup = 1 << 26,
-        Modal = 1 << 27,
-        ChildMenu = 1 << 28,
+        NoTitleBar = 1,
+        NoResize = 2,
+        NoMove = 4,
+        NoScrollbar = 8,
+        NoScrollWithMouse = 16,
+        NoCollapse = 32,
+        AlwaysAutoResize = 64,
+        NoBackground = 128,
+        NoSavedSettings = 256,
+        NoMouseInputs = 512,
+        MenuBar = 1024,
+        HorizontalScrollbar = 2048,
+        NoFocusOnAppearing = 4096,
+        NoBringToFrontOnFocus = 8192,
+        AlwaysVerticalScrollbar = 16384,
+        AlwaysHorizontalScrollbar = 32768,
+        NoNavInputs = 65536,
+        NoNavFocus = 131072,
+        UnsavedDocument = 262144,
+        NoDocking = 524288,
+        NoNav = 196608,
+        NoDecoration = 43,
+        NoInputs = 197120,
+        ChildWindow = 16777216,
+        Tooltip = 33554432,
+        Popup = 67108864,
+        Modal = 134217728,
+        ChildMenu = 268435456,
+        DockNodeHost = 536870912,
     }
 }
diff --git a/src/ImGui.NET/Generated/STB_TexteditState.gen.cs b/src/ImGui.NET/Generated/STB_TexteditState.gen.cs
new file mode 100644
index 00000000..92607563
--- /dev/null
+++ b/src/ImGui.NET/Generated/STB_TexteditState.gen.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct STB_TexteditState
+    {
+        public int cursor;
+        public int select_start;
+        public int select_end;
+        public byte insert_mode;
+        public int row_count_per_page;
+        public byte cursor_at_end_of_line;
+        public byte initialized;
+        public byte has_preferred_x;
+        public byte single_line;
+        public byte padding1;
+        public byte padding2;
+        public byte padding3;
+        public float preferred_x;
+        public StbUndoState undostate;
+    }
+    public unsafe partial struct STB_TexteditStatePtr
+    {
+        public STB_TexteditState* NativePtr { get; }
+        public STB_TexteditStatePtr(STB_TexteditState* nativePtr) => NativePtr = nativePtr;
+        public STB_TexteditStatePtr(IntPtr nativePtr) => NativePtr = (STB_TexteditState*)nativePtr;
+        public static implicit operator STB_TexteditStatePtr(STB_TexteditState* nativePtr) => new STB_TexteditStatePtr(nativePtr);
+        public static implicit operator STB_TexteditState* (STB_TexteditStatePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator STB_TexteditStatePtr(IntPtr nativePtr) => new STB_TexteditStatePtr(nativePtr);
+        public ref int cursor => ref Unsafe.AsRef<int>(&NativePtr->cursor);
+        public ref int select_start => ref Unsafe.AsRef<int>(&NativePtr->select_start);
+        public ref int select_end => ref Unsafe.AsRef<int>(&NativePtr->select_end);
+        public ref byte insert_mode => ref Unsafe.AsRef<byte>(&NativePtr->insert_mode);
+        public ref int row_count_per_page => ref Unsafe.AsRef<int>(&NativePtr->row_count_per_page);
+        public ref byte cursor_at_end_of_line => ref Unsafe.AsRef<byte>(&NativePtr->cursor_at_end_of_line);
+        public ref byte initialized => ref Unsafe.AsRef<byte>(&NativePtr->initialized);
+        public ref byte has_preferred_x => ref Unsafe.AsRef<byte>(&NativePtr->has_preferred_x);
+        public ref byte single_line => ref Unsafe.AsRef<byte>(&NativePtr->single_line);
+        public ref byte padding1 => ref Unsafe.AsRef<byte>(&NativePtr->padding1);
+        public ref byte padding2 => ref Unsafe.AsRef<byte>(&NativePtr->padding2);
+        public ref byte padding3 => ref Unsafe.AsRef<byte>(&NativePtr->padding3);
+        public ref float preferred_x => ref Unsafe.AsRef<float>(&NativePtr->preferred_x);
+        public ref StbUndoState undostate => ref Unsafe.AsRef<StbUndoState>(&NativePtr->undostate);
+    }
+}
diff --git a/src/ImGui.NET/Generated/StbTexteditRow.gen.cs b/src/ImGui.NET/Generated/StbTexteditRow.gen.cs
new file mode 100644
index 00000000..331edfac
--- /dev/null
+++ b/src/ImGui.NET/Generated/StbTexteditRow.gen.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct StbTexteditRow
+    {
+        public float x0;
+        public float x1;
+        public float baseline_y_delta;
+        public float ymin;
+        public float ymax;
+        public int num_chars;
+    }
+    public unsafe partial struct StbTexteditRowPtr
+    {
+        public StbTexteditRow* NativePtr { get; }
+        public StbTexteditRowPtr(StbTexteditRow* nativePtr) => NativePtr = nativePtr;
+        public StbTexteditRowPtr(IntPtr nativePtr) => NativePtr = (StbTexteditRow*)nativePtr;
+        public static implicit operator StbTexteditRowPtr(StbTexteditRow* nativePtr) => new StbTexteditRowPtr(nativePtr);
+        public static implicit operator StbTexteditRow* (StbTexteditRowPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator StbTexteditRowPtr(IntPtr nativePtr) => new StbTexteditRowPtr(nativePtr);
+        public ref float x0 => ref Unsafe.AsRef<float>(&NativePtr->x0);
+        public ref float x1 => ref Unsafe.AsRef<float>(&NativePtr->x1);
+        public ref float baseline_y_delta => ref Unsafe.AsRef<float>(&NativePtr->baseline_y_delta);
+        public ref float ymin => ref Unsafe.AsRef<float>(&NativePtr->ymin);
+        public ref float ymax => ref Unsafe.AsRef<float>(&NativePtr->ymax);
+        public ref int num_chars => ref Unsafe.AsRef<int>(&NativePtr->num_chars);
+    }
+}
diff --git a/src/ImGui.NET/Generated/StbUndoRecord.gen.cs b/src/ImGui.NET/Generated/StbUndoRecord.gen.cs
new file mode 100644
index 00000000..78d660f6
--- /dev/null
+++ b/src/ImGui.NET/Generated/StbUndoRecord.gen.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct StbUndoRecord
+    {
+        public int where;
+        public int insert_length;
+        public int delete_length;
+        public int char_storage;
+    }
+    public unsafe partial struct StbUndoRecordPtr
+    {
+        public StbUndoRecord* NativePtr { get; }
+        public StbUndoRecordPtr(StbUndoRecord* nativePtr) => NativePtr = nativePtr;
+        public StbUndoRecordPtr(IntPtr nativePtr) => NativePtr = (StbUndoRecord*)nativePtr;
+        public static implicit operator StbUndoRecordPtr(StbUndoRecord* nativePtr) => new StbUndoRecordPtr(nativePtr);
+        public static implicit operator StbUndoRecord* (StbUndoRecordPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator StbUndoRecordPtr(IntPtr nativePtr) => new StbUndoRecordPtr(nativePtr);
+        public ref int where => ref Unsafe.AsRef<int>(&NativePtr->where);
+        public ref int insert_length => ref Unsafe.AsRef<int>(&NativePtr->insert_length);
+        public ref int delete_length => ref Unsafe.AsRef<int>(&NativePtr->delete_length);
+        public ref int char_storage => ref Unsafe.AsRef<int>(&NativePtr->char_storage);
+    }
+}
diff --git a/src/ImGui.NET/Generated/StbUndoState.gen.cs b/src/ImGui.NET/Generated/StbUndoState.gen.cs
new file mode 100644
index 00000000..a8428a61
--- /dev/null
+++ b/src/ImGui.NET/Generated/StbUndoState.gen.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public unsafe partial struct StbUndoState
+    {
+        public StbUndoRecord undo_rec_0;
+        public StbUndoRecord undo_rec_1;
+        public StbUndoRecord undo_rec_2;
+        public StbUndoRecord undo_rec_3;
+        public StbUndoRecord undo_rec_4;
+        public StbUndoRecord undo_rec_5;
+        public StbUndoRecord undo_rec_6;
+        public StbUndoRecord undo_rec_7;
+        public StbUndoRecord undo_rec_8;
+        public StbUndoRecord undo_rec_9;
+        public StbUndoRecord undo_rec_10;
+        public StbUndoRecord undo_rec_11;
+        public StbUndoRecord undo_rec_12;
+        public StbUndoRecord undo_rec_13;
+        public StbUndoRecord undo_rec_14;
+        public StbUndoRecord undo_rec_15;
+        public StbUndoRecord undo_rec_16;
+        public StbUndoRecord undo_rec_17;
+        public StbUndoRecord undo_rec_18;
+        public StbUndoRecord undo_rec_19;
+        public StbUndoRecord undo_rec_20;
+        public StbUndoRecord undo_rec_21;
+        public StbUndoRecord undo_rec_22;
+        public StbUndoRecord undo_rec_23;
+        public StbUndoRecord undo_rec_24;
+        public StbUndoRecord undo_rec_25;
+        public StbUndoRecord undo_rec_26;
+        public StbUndoRecord undo_rec_27;
+        public StbUndoRecord undo_rec_28;
+        public StbUndoRecord undo_rec_29;
+        public StbUndoRecord undo_rec_30;
+        public StbUndoRecord undo_rec_31;
+        public StbUndoRecord undo_rec_32;
+        public StbUndoRecord undo_rec_33;
+        public StbUndoRecord undo_rec_34;
+        public StbUndoRecord undo_rec_35;
+        public StbUndoRecord undo_rec_36;
+        public StbUndoRecord undo_rec_37;
+        public StbUndoRecord undo_rec_38;
+        public StbUndoRecord undo_rec_39;
+        public StbUndoRecord undo_rec_40;
+        public StbUndoRecord undo_rec_41;
+        public StbUndoRecord undo_rec_42;
+        public StbUndoRecord undo_rec_43;
+        public StbUndoRecord undo_rec_44;
+        public StbUndoRecord undo_rec_45;
+        public StbUndoRecord undo_rec_46;
+        public StbUndoRecord undo_rec_47;
+        public StbUndoRecord undo_rec_48;
+        public StbUndoRecord undo_rec_49;
+        public StbUndoRecord undo_rec_50;
+        public StbUndoRecord undo_rec_51;
+        public StbUndoRecord undo_rec_52;
+        public StbUndoRecord undo_rec_53;
+        public StbUndoRecord undo_rec_54;
+        public StbUndoRecord undo_rec_55;
+        public StbUndoRecord undo_rec_56;
+        public StbUndoRecord undo_rec_57;
+        public StbUndoRecord undo_rec_58;
+        public StbUndoRecord undo_rec_59;
+        public StbUndoRecord undo_rec_60;
+        public StbUndoRecord undo_rec_61;
+        public StbUndoRecord undo_rec_62;
+        public StbUndoRecord undo_rec_63;
+        public StbUndoRecord undo_rec_64;
+        public StbUndoRecord undo_rec_65;
+        public StbUndoRecord undo_rec_66;
+        public StbUndoRecord undo_rec_67;
+        public StbUndoRecord undo_rec_68;
+        public StbUndoRecord undo_rec_69;
+        public StbUndoRecord undo_rec_70;
+        public StbUndoRecord undo_rec_71;
+        public StbUndoRecord undo_rec_72;
+        public StbUndoRecord undo_rec_73;
+        public StbUndoRecord undo_rec_74;
+        public StbUndoRecord undo_rec_75;
+        public StbUndoRecord undo_rec_76;
+        public StbUndoRecord undo_rec_77;
+        public StbUndoRecord undo_rec_78;
+        public StbUndoRecord undo_rec_79;
+        public StbUndoRecord undo_rec_80;
+        public StbUndoRecord undo_rec_81;
+        public StbUndoRecord undo_rec_82;
+        public StbUndoRecord undo_rec_83;
+        public StbUndoRecord undo_rec_84;
+        public StbUndoRecord undo_rec_85;
+        public StbUndoRecord undo_rec_86;
+        public StbUndoRecord undo_rec_87;
+        public StbUndoRecord undo_rec_88;
+        public StbUndoRecord undo_rec_89;
+        public StbUndoRecord undo_rec_90;
+        public StbUndoRecord undo_rec_91;
+        public StbUndoRecord undo_rec_92;
+        public StbUndoRecord undo_rec_93;
+        public StbUndoRecord undo_rec_94;
+        public StbUndoRecord undo_rec_95;
+        public StbUndoRecord undo_rec_96;
+        public StbUndoRecord undo_rec_97;
+        public StbUndoRecord undo_rec_98;
+        public fixed ushort undo_char[999];
+        public short undo_point;
+        public short redo_point;
+        public int undo_char_point;
+        public int redo_char_point;
+    }
+    public unsafe partial struct StbUndoStatePtr
+    {
+        public StbUndoState* NativePtr { get; }
+        public StbUndoStatePtr(StbUndoState* nativePtr) => NativePtr = nativePtr;
+        public StbUndoStatePtr(IntPtr nativePtr) => NativePtr = (StbUndoState*)nativePtr;
+        public static implicit operator StbUndoStatePtr(StbUndoState* nativePtr) => new StbUndoStatePtr(nativePtr);
+        public static implicit operator StbUndoState* (StbUndoStatePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator StbUndoStatePtr(IntPtr nativePtr) => new StbUndoStatePtr(nativePtr);
+        public RangeAccessor<StbUndoRecord> undo_rec => new RangeAccessor<StbUndoRecord>(&NativePtr->undo_rec_0, 99);
+        public RangeAccessor<ushort> undo_char => new RangeAccessor<ushort>(NativePtr->undo_char, 999);
+        public ref short undo_point => ref Unsafe.AsRef<short>(&NativePtr->undo_point);
+        public ref short redo_point => ref Unsafe.AsRef<short>(&NativePtr->redo_point);
+        public ref int undo_char_point => ref Unsafe.AsRef<int>(&NativePtr->undo_char_point);
+        public ref int redo_char_point => ref Unsafe.AsRef<int>(&NativePtr->redo_char_point);
+    }
+}
diff --git a/src/ImGui.NET/Generated/TextRange.gen.cs b/src/ImGui.NET/Generated/TextRange.gen.cs
deleted file mode 100644
index 75322339..00000000
--- a/src/ImGui.NET/Generated/TextRange.gen.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Text;
-
-namespace ImGuiNET
-{
-    public unsafe partial struct TextRange
-    {
-        public byte* b;
-        public byte* e;
-    }
-    public unsafe partial struct TextRangePtr
-    {
-        public TextRange* NativePtr { get; }
-        public TextRangePtr(TextRange* nativePtr) => NativePtr = nativePtr;
-        public TextRangePtr(IntPtr nativePtr) => NativePtr = (TextRange*)nativePtr;
-        public static implicit operator TextRangePtr(TextRange* nativePtr) => new TextRangePtr(nativePtr);
-        public static implicit operator TextRange* (TextRangePtr wrappedPtr) => wrappedPtr.NativePtr;
-        public static implicit operator TextRangePtr(IntPtr nativePtr) => new TextRangePtr(nativePtr);
-        public IntPtr b { get => (IntPtr)NativePtr->b; set => NativePtr->b = (byte*)value; }
-        public IntPtr e { get => (IntPtr)NativePtr->e; set => NativePtr->e = (byte*)value; }
-        public string begin()
-        {
-            byte* ret = ImGuiNative.TextRange_begin(NativePtr);
-            return Util.StringFromPtr(ret);
-        }
-        public bool empty()
-        {
-            byte ret = ImGuiNative.TextRange_empty(NativePtr);
-            return ret != 0;
-        }
-        public string end()
-        {
-            byte* ret = ImGuiNative.TextRange_end(NativePtr);
-            return Util.StringFromPtr(ret);
-        }
-        public void split(byte separator, out ImVector @out)
-        {
-            fixed (ImVector* native_out = &@out)
-            {
-                ImGuiNative.TextRange_split(NativePtr, separator, native_out);
-            }
-        }
-    }
-}
diff --git a/src/ImGui.NET/ImDrawData.Manual.cs b/src/ImGui.NET/ImDrawData.Manual.cs
deleted file mode 100644
index ddb50414..00000000
--- a/src/ImGui.NET/ImDrawData.Manual.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace ImGuiNET
-{
-    public unsafe partial struct ImDrawDataPtr
-    {
-        public RangePtrAccessor<ImDrawListPtr> CmdListsRange => new RangePtrAccessor<ImDrawListPtr>(CmdLists.ToPointer(), CmdListsCount);
-    }
-}
diff --git a/src/ImGui.NET/ImDrawList.Manual.cs b/src/ImGui.NET/ImDrawList.Manual.cs
deleted file mode 100644
index 4d46536e..00000000
--- a/src/ImGui.NET/ImDrawList.Manual.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using System.Numerics;
-using System.Text;
-
-namespace ImGuiNET
-{
-    public unsafe partial struct ImDrawListPtr
-    {
-        public void AddText(Vector2 pos, uint col, string text_begin)
-        {
-            int text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
-            byte* native_text_begin = stackalloc byte[text_begin_byteCount + 1];
-            fixed (char* text_begin_ptr = text_begin)
-            {
-                int native_text_begin_offset = Encoding.UTF8.GetBytes(text_begin_ptr, text_begin.Length, native_text_begin, text_begin_byteCount);
-                native_text_begin[native_text_begin_offset] = 0;
-            }
-            byte* native_text_end = null;
-            ImGuiNative.ImDrawList_AddText(NativePtr, pos, col, native_text_begin, native_text_end);
-        }
-
-        public void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin)
-        {
-            ImFont* native_font = font.NativePtr;
-            int text_begin_byteCount = Encoding.UTF8.GetByteCount(text_begin);
-            byte* native_text_begin = stackalloc byte[text_begin_byteCount + 1];
-            fixed (char* text_begin_ptr = text_begin)
-            {
-                int native_text_begin_offset = Encoding.UTF8.GetBytes(text_begin_ptr, text_begin.Length, native_text_begin, text_begin_byteCount);
-                native_text_begin[native_text_begin_offset] = 0;
-            }
-            byte* native_text_end = null;
-            float wrap_width = 0.0f;
-            Vector4* cpu_fine_clip_rect = null;
-            ImGuiNative.ImDrawList_AddTextFontPtr(NativePtr, native_font, font_size, pos, col, native_text_begin, native_text_end, wrap_width, cpu_fine_clip_rect);
-        }
-    }
-}
diff --git a/src/ImGui.NET/ImGui.Manual.ReadOnlySpan.cs b/src/ImGui.NET/ImGui.Manual.ReadOnlySpan.cs
new file mode 100644
index 00000000..8fe914f2
--- /dev/null
+++ b/src/ImGui.NET/ImGui.Manual.ReadOnlySpan.cs
@@ -0,0 +1,515 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+// NOTE:
+// This is a direct copy from ImGui.Manual.cs with all string parameters (not ref string) changed to ReadOnlySpan<char>.
+// TODO: This is far from ideal right now, maybe we could update the generator to do this for us.
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+namespace ImGuiNET
+{
+    public static unsafe partial class ImGui
+    {
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            byte[] buf,
+            uint buf_size)
+        {
+            return InputText(label, buf, buf_size, 0, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            byte[] buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags)
+        {
+            return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            byte[] buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback)
+        {
+            return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            byte[] buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            bool ret;
+            fixed (byte* bufPtr = buf)
+            {
+                ret = ImGuiNative.igInputText(utf8LabelBytes, bufPtr, buf_size, flags, callback, user_data.ToPointer()) != 0;
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+
+            return ret;
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength) => InputText(label, ref input, maxLength, 0, null, IntPtr.Zero);
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags) => InputText(label, ref input, maxLength, flags, null, IntPtr.Zero);
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback) => InputText(label, ref input, maxLength, flags, callback, IntPtr.Zero);
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
+            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
+
+            byte* utf8InputBytes;
+            byte* originalUtf8InputBytes;
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                utf8InputBytes = Util.Allocate(inputBufSize);
+                originalUtf8InputBytes = Util.Allocate(inputBufSize);
+            }
+            else
+            {
+                byte* inputStackBytes = stackalloc byte[inputBufSize];
+                utf8InputBytes = inputStackBytes;
+                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
+                originalUtf8InputBytes = originalInputStackBytes;
+            }
+            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
+            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
+            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
+            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
+
+            byte result = ImGuiNative.igInputText(
+                utf8LabelBytes,
+                utf8InputBytes,
+                (uint)inputBufSize,
+                flags,
+                callback,
+                user_data.ToPointer());
+            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
+            {
+                input = Util.StringFromPtr(utf8InputBytes);
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8InputBytes);
+                Util.Free(originalUtf8InputBytes);
+            }
+
+            return result != 0;
+        }
+
+        public static bool InputTextMultiline(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            Vector2 size) => InputTextMultiline(label, ref input, maxLength, size, 0, null, IntPtr.Zero);
+
+        public static bool InputTextMultiline(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            Vector2 size,
+            ImGuiInputTextFlags flags) => InputTextMultiline(label, ref input, maxLength, size, flags, null, IntPtr.Zero);
+
+        public static bool InputTextMultiline(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            Vector2 size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback) => InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
+
+        public static bool InputTextMultiline(
+            ReadOnlySpan<char> label,
+            ref string input,
+            uint maxLength,
+            Vector2 size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
+            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
+
+            byte* utf8InputBytes;
+            byte* originalUtf8InputBytes;
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                utf8InputBytes = Util.Allocate(inputBufSize);
+                originalUtf8InputBytes = Util.Allocate(inputBufSize);
+            }
+            else
+            {
+                byte* inputStackBytes = stackalloc byte[inputBufSize];
+                utf8InputBytes = inputStackBytes;
+                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
+                originalUtf8InputBytes = originalInputStackBytes;
+            }
+            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
+            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
+            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
+            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
+
+            byte result = ImGuiNative.igInputTextMultiline(
+                utf8LabelBytes,
+                utf8InputBytes,
+                (uint)inputBufSize,
+                size,
+                flags,
+                callback,
+                user_data.ToPointer());
+            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
+            {
+                input = Util.StringFromPtr(utf8InputBytes);
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8InputBytes);
+                Util.Free(originalUtf8InputBytes);
+            }
+
+            return result != 0;
+        }
+
+        public static bool InputTextWithHint(
+            ReadOnlySpan<char> label,
+            ReadOnlySpan<char> hint,
+            ref string input,
+            uint maxLength) => InputTextWithHint(label, hint, ref input, maxLength, 0, null, IntPtr.Zero);
+
+        public static bool InputTextWithHint(
+            ReadOnlySpan<char> label,
+            ReadOnlySpan<char> hint,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags) => InputTextWithHint(label, hint, ref input, maxLength, flags, null, IntPtr.Zero);
+
+        public static bool InputTextWithHint(
+            ReadOnlySpan<char> label,
+            ReadOnlySpan<char> hint,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback) => InputTextWithHint(label, hint, ref input, maxLength, flags, callback, IntPtr.Zero);
+
+        public static bool InputTextWithHint(
+            ReadOnlySpan<char> label,
+            ReadOnlySpan<char> hint,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            int utf8HintByteCount = Encoding.UTF8.GetByteCount(hint);
+            byte* utf8HintBytes;
+            if (utf8HintByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8HintBytes = Util.Allocate(utf8HintByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8HintByteCount + 1];
+                utf8HintBytes = stackPtr;
+            }
+            Util.GetUtf8(hint, utf8HintBytes, utf8HintByteCount);
+
+            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
+            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
+
+            byte* utf8InputBytes;
+            byte* originalUtf8InputBytes;
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                utf8InputBytes = Util.Allocate(inputBufSize);
+                originalUtf8InputBytes = Util.Allocate(inputBufSize);
+            }
+            else
+            {
+                byte* inputStackBytes = stackalloc byte[inputBufSize];
+                utf8InputBytes = inputStackBytes;
+                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
+                originalUtf8InputBytes = originalInputStackBytes;
+            }
+            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
+            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
+            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
+            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
+
+            byte result = ImGuiNative.igInputTextWithHint(
+                utf8LabelBytes,
+                utf8HintBytes,
+                utf8InputBytes,
+                (uint)inputBufSize,
+                flags,
+                callback,
+                user_data.ToPointer());
+            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
+            {
+                input = Util.StringFromPtr(utf8InputBytes);
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+            if (utf8HintByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8HintBytes);
+            }
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8InputBytes);
+                Util.Free(originalUtf8InputBytes);
+            }
+
+            return result != 0;
+        }
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start)
+            => CalcTextSizeImpl(text, start);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, float wrapWidth)
+            => CalcTextSizeImpl(text, wrapWidth: wrapWidth);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length)
+            => CalcTextSizeImpl(text, start, length);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, bool hideTextAfterDoubleHash)
+            => CalcTextSizeImpl(text, start, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, float wrapWidth)
+            => CalcTextSizeImpl(text, start, wrapWidth: wrapWidth);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length, bool hideTextAfterDoubleHash)
+            => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length, float wrapWidth)
+            => CalcTextSizeImpl(text, start, length, wrapWidth: wrapWidth);
+
+        public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
+            => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
+
+        private static Vector2 CalcTextSizeImpl(
+            ReadOnlySpan<char> text,
+            int start = 0,
+            int? length = null,
+            bool hideTextAfterDoubleHash = false,
+            float wrapWidth = -1.0f)
+        {
+            return CalcTextSize(text.Slice(start, length ?? text.Length-start), hideTextAfterDoubleHash, wrapWidth);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            IntPtr buf,
+            uint buf_size)
+        {
+            return InputText(label, buf, buf_size, 0, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            IntPtr buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags)
+        {
+            return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            IntPtr buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback)
+        {
+            return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            ReadOnlySpan<char> label,
+            IntPtr buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            bool ret = ImGuiNative.igInputText(utf8LabelBytes, (byte*)buf.ToPointer(), buf_size, flags, callback, user_data.ToPointer()) != 0;
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+
+            return ret;
+        }
+
+        public static bool Begin(ReadOnlySpan<char> name, ImGuiWindowFlags flags)
+        {
+            int utf8NameByteCount = Encoding.UTF8.GetByteCount(name);
+            byte* utf8NameBytes;
+            if (utf8NameByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8NameBytes = Util.Allocate(utf8NameByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8NameByteCount + 1];
+                utf8NameBytes = stackPtr;
+            }
+            Util.GetUtf8(name, utf8NameBytes, utf8NameByteCount);
+
+            byte* p_open = null;
+            byte ret = ImGuiNative.igBegin(utf8NameBytes, p_open, flags);
+
+            if (utf8NameByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8NameBytes);
+            }
+
+            return ret != 0;
+        }
+
+        public static bool MenuItem(ReadOnlySpan<char> label, bool enabled)
+        {
+            return MenuItem(label, string.Empty, false, enabled);
+        }
+
+        public static bool BeginPopupModal(ReadOnlySpan<char> name, ImGuiWindowFlags flags)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte* native_p_open = null;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+
+            return ret != 0;
+        }
+    }
+}
+#endif
diff --git a/src/ImGui.NET/ImGui.Manual.cs b/src/ImGui.NET/ImGui.Manual.cs
index 522c6f7c..00c183d7 100644
--- a/src/ImGui.NET/ImGui.Manual.cs
+++ b/src/ImGui.NET/ImGui.Manual.cs
@@ -1,339 +1,510 @@
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace ImGuiNET
-{
-    public static unsafe partial class ImGui
-    {
-        public static bool InputText(
-            string label,
-            byte[] buf,
-            uint buf_size)
-        {
-            return InputText(label, buf, buf_size, 0, null, IntPtr.Zero);
-        }
-
-        public static bool InputText(
-            string label,
-            byte[] buf,
-            uint buf_size,
-            ImGuiInputTextFlags flags)
-        {
-            return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
-        }
-
-        public static bool InputText(
-            string label,
-            byte[] buf,
-            uint buf_size,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback)
-        {
-            return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
-        }
-
-        public static bool InputText(
-            string label,
-            byte[] buf,
-            uint buf_size,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback,
-            IntPtr user_data)
-        {
-            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
-            byte* utf8LabelBytes;
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
-            }
-            else
-            {
-                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
-                utf8LabelBytes = stackPtr;
-            }
-            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
-
-            bool ret;
-            fixed (byte* bufPtr = buf)
-            {
-                ret = ImGuiNative.igInputText(utf8LabelBytes, bufPtr, buf_size, flags, callback, user_data.ToPointer()) != 0;
-            }
-
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8LabelBytes);
-            }
-
-            return ret;
-        }
-
-        public static bool InputText(
-            string label,
-            ref string input,
-            uint maxLength) => InputText(label, ref input, maxLength, 0, null, IntPtr.Zero);
-
-        public static bool InputText(
-            string label,
-            ref string input,
-            uint maxLength,
-            ImGuiInputTextFlags flags) => InputText(label, ref input, maxLength, flags, null, IntPtr.Zero);
-
-        public static bool InputText(
-            string label,
-            ref string input,
-            uint maxLength,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback) => InputText(label, ref input, maxLength, flags, callback, IntPtr.Zero);
-
-        public static bool InputText(
-            string label,
-            ref string input,
-            uint maxLength,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback,
-            IntPtr user_data)
-        {
-            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
-            byte* utf8LabelBytes;
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
-            }
-            else
-            {
-                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
-                utf8LabelBytes = stackPtr;
-            }
-            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
-
-            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
-            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
-
-            byte* utf8InputBytes;
-            byte* originalUtf8InputBytes;
-            if (inputBufSize > Util.StackAllocationSizeLimit)
-            {
-                utf8InputBytes = Util.Allocate(inputBufSize);
-                originalUtf8InputBytes = Util.Allocate(inputBufSize);
-            }
-            else
-            {
-                byte* inputStackBytes = stackalloc byte[inputBufSize];
-                utf8InputBytes = inputStackBytes;
-                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
-                originalUtf8InputBytes = originalInputStackBytes;
-            }
-            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
-            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
-            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
-            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
-
-            byte result = ImGuiNative.igInputText(
-                utf8LabelBytes,
-                utf8InputBytes,
-                (uint)inputBufSize,
-                flags,
-                callback,
-                user_data.ToPointer());
-            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
-            {
-                input = Util.StringFromPtr(utf8InputBytes);
-            }
-
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8LabelBytes);
-            }
-            if (inputBufSize > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8InputBytes);
-                Util.Free(originalUtf8InputBytes);
-            }
-
-            return result != 0;
-        }
-
-        public static bool InputTextMultiline(
-            string label,
-            ref string input,
-            uint maxLength,
-            Vector2 size) => InputTextMultiline(label, ref input, maxLength, size, 0, null, IntPtr.Zero);
-
-        public static bool InputTextMultiline(
-            string label,
-            ref string input,
-            uint maxLength,
-            Vector2 size,
-            ImGuiInputTextFlags flags) => InputTextMultiline(label, ref input, maxLength, size, flags, null, IntPtr.Zero);
-
-        public static bool InputTextMultiline(
-            string label,
-            ref string input,
-            uint maxLength,
-            Vector2 size,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback) => InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
-
-        public static bool InputTextMultiline(
-            string label,
-            ref string input,
-            uint maxLength,
-            Vector2 size,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback,
-            IntPtr user_data)
-        {
-            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
-            byte* utf8LabelBytes;
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
-            }
-            else
-            {
-                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
-                utf8LabelBytes = stackPtr;
-            }
-            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
-
-            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
-            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
-
-            byte* utf8InputBytes;
-            byte* originalUtf8InputBytes;
-            if (inputBufSize > Util.StackAllocationSizeLimit)
-            {
-                utf8InputBytes = Util.Allocate(inputBufSize);
-                originalUtf8InputBytes = Util.Allocate(inputBufSize);
-            }
-            else
-            {
-                byte* inputStackBytes = stackalloc byte[inputBufSize];
-                utf8InputBytes = inputStackBytes;
-                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
-                originalUtf8InputBytes = originalInputStackBytes;
-            }
-            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
-            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
-            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
-            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
-
-            byte result = ImGuiNative.igInputTextMultiline(
-                utf8LabelBytes,
-                utf8InputBytes,
-                (uint)inputBufSize,
-                size,
-                flags,
-                callback,
-                user_data.ToPointer());
-            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
-            {
-                input = Util.StringFromPtr(utf8InputBytes);
-            }
-
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8LabelBytes);
-            }
-            if (inputBufSize > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8InputBytes);
-                Util.Free(originalUtf8InputBytes);
-            }
-
-            return result != 0;
-        }
-
-        public static bool InputText(
-            string label,
-            IntPtr buf,
-            uint buf_size)
-        {
-            return InputText(label, buf, buf_size, 0, null, IntPtr.Zero);
-        }
-
-        public static bool InputText(
-            string label,
-            IntPtr buf,
-            uint buf_size,
-            ImGuiInputTextFlags flags)
-        {
-            return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
-        }
-
-        public static bool InputText(
-            string label,
-            IntPtr buf,
-            uint buf_size,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback)
-        {
-            return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
-        }
-
-        public static bool InputText(
-            string label,
-            IntPtr buf,
-            uint buf_size,
-            ImGuiInputTextFlags flags,
-            ImGuiInputTextCallback callback,
-            IntPtr user_data)
-        {
-            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
-            byte* utf8LabelBytes;
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
-            }
-            else
-            {
-                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
-                utf8LabelBytes = stackPtr;
-            }
-            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
-
-            bool ret = ImGuiNative.igInputText(utf8LabelBytes, (byte*)buf.ToPointer(), buf_size, flags, callback, user_data.ToPointer()) != 0;
-
-            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8LabelBytes);
-            }
-
-            return ret;
-        }
-
-        public static bool Begin(string name, ImGuiWindowFlags flags)
-        {
-            int utf8NameByteCount = Encoding.UTF8.GetByteCount(name);
-            byte* utf8NameBytes;
-            if (utf8NameByteCount > Util.StackAllocationSizeLimit)
-            {
-                utf8NameBytes = Util.Allocate(utf8NameByteCount + 1);
-            }
-            else
-            {
-                byte* stackPtr = stackalloc byte[utf8NameByteCount + 1];
-                utf8NameBytes = stackPtr;
-            }
-            Util.GetUtf8(name, utf8NameBytes, utf8NameByteCount);
-
-            byte* p_open = null;
-            byte ret = ImGuiNative.igBegin(utf8NameBytes, p_open, flags);
-
-            if (utf8NameByteCount > Util.StackAllocationSizeLimit)
-            {
-                Util.Free(utf8NameBytes);
-            }
-
-            return ret != 0;
-        }
-
-        public static bool MenuItem(string label, bool enabled)
-        {
-            return MenuItem(label, string.Empty, false, enabled);
-        }
-    }
-}
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImGui
+    {
+        public static bool InputText(
+            string label,
+            byte[] buf,
+            uint buf_size)
+        {
+            return InputText(label, buf, buf_size, 0, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            string label,
+            byte[] buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags)
+        {
+            return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            string label,
+            byte[] buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback)
+        {
+            return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            string label,
+            byte[] buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            bool ret;
+            fixed (byte* bufPtr = buf)
+            {
+                ret = ImGuiNative.igInputText(utf8LabelBytes, bufPtr, buf_size, flags, callback, user_data.ToPointer()) != 0;
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+
+            return ret;
+        }
+
+        public static bool InputText(
+            string label,
+            ref string input,
+            uint maxLength) => InputText(label, ref input, maxLength, 0, null, IntPtr.Zero);
+
+        public static bool InputText(
+            string label,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags) => InputText(label, ref input, maxLength, flags, null, IntPtr.Zero);
+
+        public static bool InputText(
+            string label,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback) => InputText(label, ref input, maxLength, flags, callback, IntPtr.Zero);
+
+        public static bool InputText(
+            string label,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
+            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
+
+            byte* utf8InputBytes;
+            byte* originalUtf8InputBytes;
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                utf8InputBytes = Util.Allocate(inputBufSize);
+                originalUtf8InputBytes = Util.Allocate(inputBufSize);
+            }
+            else
+            {
+                byte* inputStackBytes = stackalloc byte[inputBufSize];
+                utf8InputBytes = inputStackBytes;
+                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
+                originalUtf8InputBytes = originalInputStackBytes;
+            }
+            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
+            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
+            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
+            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
+
+            byte result = ImGuiNative.igInputText(
+                utf8LabelBytes,
+                utf8InputBytes,
+                (uint)inputBufSize,
+                flags,
+                callback,
+                user_data.ToPointer());
+            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
+            {
+                input = Util.StringFromPtr(utf8InputBytes);
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8InputBytes);
+                Util.Free(originalUtf8InputBytes);
+            }
+
+            return result != 0;
+        }
+
+        public static bool InputTextMultiline(
+            string label,
+            ref string input,
+            uint maxLength,
+            Vector2 size) => InputTextMultiline(label, ref input, maxLength, size, 0, null, IntPtr.Zero);
+
+        public static bool InputTextMultiline(
+            string label,
+            ref string input,
+            uint maxLength,
+            Vector2 size,
+            ImGuiInputTextFlags flags) => InputTextMultiline(label, ref input, maxLength, size, flags, null, IntPtr.Zero);
+
+        public static bool InputTextMultiline(
+            string label,
+            ref string input,
+            uint maxLength,
+            Vector2 size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback) => InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
+
+        public static bool InputTextMultiline(
+            string label,
+            ref string input,
+            uint maxLength,
+            Vector2 size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
+            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
+
+            byte* utf8InputBytes;
+            byte* originalUtf8InputBytes;
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                utf8InputBytes = Util.Allocate(inputBufSize);
+                originalUtf8InputBytes = Util.Allocate(inputBufSize);
+            }
+            else
+            {
+                byte* inputStackBytes = stackalloc byte[inputBufSize];
+                utf8InputBytes = inputStackBytes;
+                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
+                originalUtf8InputBytes = originalInputStackBytes;
+            }
+            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
+            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
+            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
+            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
+
+            byte result = ImGuiNative.igInputTextMultiline(
+                utf8LabelBytes,
+                utf8InputBytes,
+                (uint)inputBufSize,
+                size,
+                flags,
+                callback,
+                user_data.ToPointer());
+            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
+            {
+                input = Util.StringFromPtr(utf8InputBytes);
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8InputBytes);
+                Util.Free(originalUtf8InputBytes);
+            }
+
+            return result != 0;
+        }
+
+        public static bool InputTextWithHint(
+            string label,
+            string hint,
+            ref string input,
+            uint maxLength) => InputTextWithHint(label, hint, ref input, maxLength, 0, null, IntPtr.Zero);
+
+        public static bool InputTextWithHint(
+            string label,
+            string hint,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags) => InputTextWithHint(label, hint, ref input, maxLength, flags, null, IntPtr.Zero);
+
+        public static bool InputTextWithHint(
+            string label,
+            string hint,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback) => InputTextWithHint(label, hint, ref input, maxLength, flags, callback, IntPtr.Zero);
+
+        public static bool InputTextWithHint(
+            string label,
+            string hint,
+            ref string input,
+            uint maxLength,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            int utf8HintByteCount = Encoding.UTF8.GetByteCount(hint);
+            byte* utf8HintBytes;
+            if (utf8HintByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8HintBytes = Util.Allocate(utf8HintByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8HintByteCount + 1];
+                utf8HintBytes = stackPtr;
+            }
+            Util.GetUtf8(hint, utf8HintBytes, utf8HintByteCount);
+
+            int utf8InputByteCount = Encoding.UTF8.GetByteCount(input);
+            int inputBufSize = Math.Max((int)maxLength + 1, utf8InputByteCount + 1);
+
+            byte* utf8InputBytes;
+            byte* originalUtf8InputBytes;
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                utf8InputBytes = Util.Allocate(inputBufSize);
+                originalUtf8InputBytes = Util.Allocate(inputBufSize);
+            }
+            else
+            {
+                byte* inputStackBytes = stackalloc byte[inputBufSize];
+                utf8InputBytes = inputStackBytes;
+                byte* originalInputStackBytes = stackalloc byte[inputBufSize];
+                originalUtf8InputBytes = originalInputStackBytes;
+            }
+            Util.GetUtf8(input, utf8InputBytes, inputBufSize);
+            uint clearBytesCount = (uint)(inputBufSize - utf8InputByteCount);
+            Unsafe.InitBlockUnaligned(utf8InputBytes + utf8InputByteCount, 0, clearBytesCount);
+            Unsafe.CopyBlock(originalUtf8InputBytes, utf8InputBytes, (uint)inputBufSize);
+
+            byte result = ImGuiNative.igInputTextWithHint(
+                utf8LabelBytes,
+                utf8HintBytes,
+                utf8InputBytes,
+                (uint)inputBufSize,
+                flags,
+                callback,
+                user_data.ToPointer());
+            if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, utf8InputBytes))
+            {
+                input = Util.StringFromPtr(utf8InputBytes);
+            }
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+            if (utf8HintByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8HintBytes);
+            }
+            if (inputBufSize > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8InputBytes);
+                Util.Free(originalUtf8InputBytes);
+            }
+
+            return result != 0;
+        }
+
+        public static Vector2 CalcTextSize(string text, int start)
+            => CalcTextSizeImpl(text, start);
+
+        public static Vector2 CalcTextSize(string text, float wrapWidth)
+            => CalcTextSizeImpl(text, wrapWidth: wrapWidth);
+
+        public static Vector2 CalcTextSize(string text, int start, int length)
+            => CalcTextSizeImpl(text, start, length);
+
+        public static Vector2 CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
+            => CalcTextSizeImpl(text, start, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
+
+        public static Vector2 CalcTextSize(string text, int start, float wrapWidth)
+            => CalcTextSizeImpl(text, start, wrapWidth: wrapWidth);
+
+        public static Vector2 CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
+            => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
+
+        public static Vector2 CalcTextSize(string text, int start, int length, float wrapWidth)
+            => CalcTextSizeImpl(text, start, length, wrapWidth: wrapWidth);
+
+        public static Vector2 CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
+            => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
+
+        private static Vector2 CalcTextSizeImpl(
+            string text,
+            int start = 0,
+            int? length = null,
+            bool hideTextAfterDoubleHash = false,
+            float wrapWidth = -1.0f)
+        {
+            return CalcTextSize(text.Substring(start, length ?? text.Length-start), hideTextAfterDoubleHash, wrapWidth);
+        }
+
+        public static bool InputText(
+            string label,
+            IntPtr buf,
+            uint buf_size)
+        {
+            return InputText(label, buf, buf_size, 0, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            string label,
+            IntPtr buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags)
+        {
+            return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            string label,
+            IntPtr buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback)
+        {
+            return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
+        }
+
+        public static bool InputText(
+            string label,
+            IntPtr buf,
+            uint buf_size,
+            ImGuiInputTextFlags flags,
+            ImGuiInputTextCallback callback,
+            IntPtr user_data)
+        {
+            int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
+            byte* utf8LabelBytes;
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
+                utf8LabelBytes = stackPtr;
+            }
+            Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
+
+            bool ret = ImGuiNative.igInputText(utf8LabelBytes, (byte*)buf.ToPointer(), buf_size, flags, callback, user_data.ToPointer()) != 0;
+
+            if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8LabelBytes);
+            }
+
+            return ret;
+        }
+
+        public static bool Begin(string name, ImGuiWindowFlags flags)
+        {
+            int utf8NameByteCount = Encoding.UTF8.GetByteCount(name);
+            byte* utf8NameBytes;
+            if (utf8NameByteCount > Util.StackAllocationSizeLimit)
+            {
+                utf8NameBytes = Util.Allocate(utf8NameByteCount + 1);
+            }
+            else
+            {
+                byte* stackPtr = stackalloc byte[utf8NameByteCount + 1];
+                utf8NameBytes = stackPtr;
+            }
+            Util.GetUtf8(name, utf8NameBytes, utf8NameByteCount);
+
+            byte* p_open = null;
+            byte ret = ImGuiNative.igBegin(utf8NameBytes, p_open, flags);
+
+            if (utf8NameByteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(utf8NameBytes);
+            }
+
+            return ret != 0;
+        }
+
+        public static bool MenuItem(string label, bool enabled)
+        {
+            return MenuItem(label, string.Empty, false, enabled);
+        }
+
+        public static bool BeginPopupModal(string name, ImGuiWindowFlags flags)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte* native_p_open = null;
+            byte ret = ImGuiNative.igBeginPopupModal(native_name, native_p_open, flags);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+
+            return ret != 0;
+        }
+    }
+}
diff --git a/src/ImGui.NET/ImGui.NET.csproj b/src/ImGui.NET/ImGui.NET.csproj
index 717bda1e..b8e466a0 100644
--- a/src/ImGui.NET/ImGui.NET.csproj
+++ b/src/ImGui.NET/ImGui.NET.csproj
@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Description>A .NET wrapper for the Dear ImGui library.</Description>
-    <AssemblyVersion>1.67.0</AssemblyVersion>
+    <AssemblyVersion>1.91.6.1</AssemblyVersion>
     <Authors>Eric Mellino</Authors>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;net6.0;net8.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DebugType>portable</DebugType>
     <AssemblyName>ImGui.NET</AssemblyName>
@@ -16,9 +16,17 @@
     <RootNamespace>ImGuiNET</RootNamespace>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="System.Numerics.Vectors" Version="4.4.0" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.4.0" />
-    <PackageReference Include="System.Buffers" Version="4.4.0" />
+    <PackageReference Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <PackageReference Include="System.Buffers" Version="4.5.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>ImPlot.NET</_Parameter1>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>ImNodes.NET</_Parameter1>
+    </AssemblyAttribute>
   </ItemGroup>
   <ItemGroup>
     <Content Include="..\..\deps\cimgui\win-x86\cimgui.dll">
@@ -29,12 +37,16 @@
       <PackagePath>runtimes/win-x64/native</PackagePath>
       <Pack>true</Pack>
     </Content>
+    <Content Include="..\..\deps\cimgui\win-arm64\cimgui.dll">
+      <PackagePath>runtimes/win-arm64/native</PackagePath>
+      <Pack>true</Pack>
+    </Content>
     <Content Include="..\..\deps\cimgui\linux-x64\cimgui.so">
       <PackagePath>runtimes/linux-x64/native/libcimgui.so</PackagePath>
       <Pack>true</Pack>
     </Content>
-    <Content Include="..\..\deps\cimgui\osx-x64\cimgui.dylib">
-      <PackagePath>runtimes/osx-x64/native/libcimgui.dylib</PackagePath>
+    <Content Include="..\..\deps\cimgui\osx\cimgui.dylib">
+      <PackagePath>runtimes/osx/native/libcimgui.dylib</PackagePath>
       <Pack>true</Pack>
     </Content>
     <Content Include="build\net40\ImGui.NET.targets">
diff --git a/src/ImGui.NET/ImGuiModFlags.Manual.cs b/src/ImGui.NET/ImGuiModFlags.Manual.cs
new file mode 100644
index 00000000..5bfbcc68
--- /dev/null
+++ b/src/ImGui.NET/ImGuiModFlags.Manual.cs
@@ -0,0 +1,12 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiModFlags
+    {
+        None = 0,
+        Ctrl = 1,
+        Shift = 2,
+        Alt = 4,
+        Super = 8,
+    }
+}
\ No newline at end of file
diff --git a/src/ImGui.NET/ImGuiNative.Manual.cs b/src/ImGui.NET/ImGuiNative.Manual.cs
new file mode 100644
index 00000000..be8cbdc9
--- /dev/null
+++ b/src/ImGui.NET/ImGuiNative.Manual.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace ImGuiNET
+{
+    public static unsafe partial class ImGuiNative
+    {
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, IntPtr funcPtr);
+        [DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, IntPtr funcPtr);
+    }
+}
diff --git a/src/ImGui.NET/ImGuiTextEditCallback.cs b/src/ImGui.NET/ImGuiTextEditCallback.cs
index 04e5500e..4c67dccc 100644
--- a/src/ImGui.NET/ImGuiTextEditCallback.cs
+++ b/src/ImGui.NET/ImGuiTextEditCallback.cs
@@ -1,4 +1,7 @@
-namespace ImGuiNET
+using System.Runtime.InteropServices;
+
+namespace ImGuiNET
 {
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     public unsafe delegate int ImGuiInputTextCallback(ImGuiInputTextCallbackData* data);
 }
diff --git a/src/ImGui.NET/ImVector.cs b/src/ImGui.NET/ImVector.cs
index 76411b86..22a51a6b 100644
--- a/src/ImGui.NET/ImVector.cs
+++ b/src/ImGui.NET/ImVector.cs
@@ -9,6 +9,13 @@ public unsafe struct ImVector
         public readonly int Capacity;
         public readonly IntPtr Data;
 
+        public ImVector(int size, int capacity, IntPtr data)
+        {
+            Size = size;
+            Capacity = capacity;
+            Data = data;
+        }
+
         public ref T Ref<T>(int index)
         {
             return ref Unsafe.AsRef<T>((byte*)Data + index * Unsafe.SizeOf<T>());
diff --git a/src/ImGui.NET/Pair.cs b/src/ImGui.NET/Pair.cs
index 23e0332e..904cde39 100644
--- a/src/ImGui.NET/Pair.cs
+++ b/src/ImGui.NET/Pair.cs
@@ -3,12 +3,22 @@
 
 namespace ImGuiNET
 {
-    public struct Pair
+    public struct ImGuiStoragePair
     {
         public uint Key;
         public UnionValue Value;
     }
 
+    public unsafe struct ImGuiStoragePairPtr
+    {
+        public ImGuiStoragePair* NativePtr { get; }
+        public ImGuiStoragePairPtr(ImGuiStoragePair* nativePtr) => NativePtr = nativePtr;
+        public ImGuiStoragePairPtr(IntPtr nativePtr) => NativePtr = (ImGuiStoragePair*)nativePtr;
+        public static implicit operator ImGuiStoragePairPtr(ImGuiStoragePair* nativePtr) => new ImGuiStoragePairPtr(nativePtr);
+        public static implicit operator ImGuiStoragePair*(ImGuiStoragePairPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiStoragePairPtr(IntPtr nativePtr) => new ImGuiStoragePairPtr(nativePtr);
+    }
+
     [StructLayout(LayoutKind.Explicit)]
     public struct UnionValue
     {
diff --git a/src/ImGui.NET/Util.cs b/src/ImGui.NET/Util.cs
index 34280a0b..438948c8 100644
--- a/src/ImGui.NET/Util.cs
+++ b/src/ImGui.NET/Util.cs
@@ -32,7 +32,42 @@ internal static bool AreStringsEqual(byte* a, int aLength, byte* b)
         }
 
         internal static byte* Allocate(int byteCount) => (byte*)Marshal.AllocHGlobal(byteCount);
+
         internal static void Free(byte* ptr) => Marshal.FreeHGlobal((IntPtr)ptr);
+
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        internal static int CalcSizeInUtf8(ReadOnlySpan<char> s, int start, int length)
+#else
+        internal static int CalcSizeInUtf8(string s, int start, int length)
+#endif
+        {
+            if (start < 0 || length < 0 || start + length > s.Length)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            if(s.Length == 0) return 0;
+
+            fixed (char* utf16Ptr = s)
+            {
+                return Encoding.UTF8.GetByteCount(utf16Ptr + start, length);
+            }
+        }
+
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        internal static int GetUtf8(ReadOnlySpan<char> s, byte* utf8Bytes, int utf8ByteCount)
+        {
+            if (s.IsEmpty)
+            {
+                return 0;
+            }
+
+            fixed (char* utf16Ptr = s)
+            {
+                return Encoding.UTF8.GetBytes(utf16Ptr, s.Length, utf8Bytes, utf8ByteCount);
+            }
+        }
+#endif
+
         internal static int GetUtf8(string s, byte* utf8Bytes, int utf8ByteCount)
         {
             fixed (char* utf16Ptr = s)
@@ -40,5 +75,23 @@ internal static int GetUtf8(string s, byte* utf8Bytes, int utf8ByteCount)
                 return Encoding.UTF8.GetBytes(utf16Ptr, s.Length, utf8Bytes, utf8ByteCount);
             }
         }
+
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        internal static int GetUtf8(ReadOnlySpan<char> s, int start, int length, byte* utf8Bytes, int utf8ByteCount)
+#else
+        internal static int GetUtf8(string s, int start, int length, byte* utf8Bytes, int utf8ByteCount)
+#endif
+        {
+            if (start < 0 || length < 0 || start + length > s.Length)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            if (s.Length == 0) return 0;
+
+            fixed (char* utf16Ptr = s)
+            {
+                return Encoding.UTF8.GetBytes(utf16Ptr + start, length, utf8Bytes, utf8ByteCount);
+            }
+        }
     }
 }
diff --git a/src/ImGui.NET/build/net40/ImGui.NET.targets b/src/ImGui.NET/build/net40/ImGui.NET.targets
index 36482b63..9e20f06a 100644
--- a/src/ImGui.NET/build/net40/ImGui.NET.targets
+++ b/src/ImGui.NET/build/net40/ImGui.NET.targets
@@ -5,13 +5,14 @@
     <_IsMacOS Condition="'$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::OSX)))' == 'true'">true</_IsMacOS>
     <_IsLinux Condition="'$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))' == 'true'">true</_IsLinux>
 
-    <_NativeRuntime Condition=" '$(_NativeRuntime)' == '' And '$(_IsMacOS)' == 'true' And ('$(Prefer32Bit)' == 'false' Or '$(PlatformTarget)' == 'x64')">osx-x64</_NativeRuntime>
+    <_NativeRuntime Condition=" '$(_NativeRuntime)' == '' And '$(_IsMacOS)' == 'true' And '$(PlatformTarget)' == 'x64'">osx</_NativeRuntime>
+    <_NativeRuntime Condition=" '$(_NativeRuntime)' == '' And '$(_IsMacOS)' == 'true' And '$(PlatformTarget)' == 'ARM64'">osx</_NativeRuntime>
     <_NativeRuntime Condition=" '$(_NativeRuntime)' == '' And '$(_IsLinux)' == 'true' And ('$(Prefer32Bit)' == 'false' Or '$(PlatformTarget)' == 'x64')">linux-x64</_NativeRuntime>
     <_NativeRuntime Condition=" '$(_NativeRuntime)' == '' And '$(_IsWindows)' == 'true' And ('$(Prefer32Bit)' == 'true' Or '$(PlatformTarget)' == 'x86')">win-x86</_NativeRuntime>
     <_NativeRuntime Condition=" '$(_NativeRuntime)' == '' And '$(_IsWindows)' == 'true' And ('$(Prefer32Bit)' == 'false' Or '$(PlatformTarget)' == 'x64')">win-x64</_NativeRuntime>
 
     <_NativeLibName Condition="'$(_NativeRuntime)' == 'win-x86' Or '$(_NativeRuntime)' == 'win-x64'">cimgui.dll</_NativeLibName>
-    <_NativeLibName Condition="'$(_NativeRuntime)' == 'osx-x64'">libcimgui.dylib</_NativeLibName>
+    <_NativeLibName Condition="'$(_NativeRuntime)' == 'osx'">libcimgui.dylib</_NativeLibName>
     <_NativeLibName Condition="'$(_NativeRuntime)' == 'linux-x64'">libcimgui.so</_NativeLibName>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/ImGuizmo.NET/Generated/ImGuizmo.gen.cs b/src/ImGuizmo.NET/Generated/ImGuizmo.gen.cs
new file mode 100644
index 00000000..b3de9a70
--- /dev/null
+++ b/src/ImGuizmo.NET/Generated/ImGuizmo.gen.cs
@@ -0,0 +1,247 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImGuizmoNET
+{
+    public static unsafe partial class ImGuizmo
+    {
+        public static void AllowAxisFlip(bool value)
+        {
+            byte native_value = value ? (byte)1 : (byte)0;
+            ImGuizmoNative.ImGuizmo_AllowAxisFlip(native_value);
+        }
+        public static void BeginFrame()
+        {
+            ImGuizmoNative.ImGuizmo_BeginFrame();
+        }
+        public static void DecomposeMatrixToComponents(ref float matrix, ref float translation, ref float rotation, ref float scale)
+        {
+            fixed (float* native_matrix = &matrix)
+            {
+                fixed (float* native_translation = &translation)
+                {
+                    fixed (float* native_rotation = &rotation)
+                    {
+                        fixed (float* native_scale = &scale)
+                        {
+                            ImGuizmoNative.ImGuizmo_DecomposeMatrixToComponents(native_matrix, native_translation, native_rotation, native_scale);
+                        }
+                    }
+                }
+            }
+        }
+        public static void DrawCubes(ref float view, ref float projection, ref float matrices, int matrixCount)
+        {
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrices = &matrices)
+                    {
+                        ImGuizmoNative.ImGuizmo_DrawCubes(native_view, native_projection, native_matrices, matrixCount);
+                    }
+                }
+            }
+        }
+        public static void DrawGrid(ref float view, ref float projection, ref float matrix, float gridSize)
+        {
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        ImGuizmoNative.ImGuizmo_DrawGrid(native_view, native_projection, native_matrix, gridSize);
+                    }
+                }
+            }
+        }
+        public static void Enable(bool enable)
+        {
+            byte native_enable = enable ? (byte)1 : (byte)0;
+            ImGuizmoNative.ImGuizmo_Enable(native_enable);
+        }
+        public static bool IsOver()
+        {
+            byte ret = ImGuizmoNative.ImGuizmo_IsOverNil();
+            return ret != 0;
+        }
+        public static bool IsOver(OPERATION op)
+        {
+            byte ret = ImGuizmoNative.ImGuizmo_IsOverOPERATION(op);
+            return ret != 0;
+        }
+        public static bool IsUsing()
+        {
+            byte ret = ImGuizmoNative.ImGuizmo_IsUsing();
+            return ret != 0;
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix)
+        {
+            float* deltaMatrix = null;
+            float* snap = null;
+            float* localBounds = null;
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, deltaMatrix, snap, localBounds, boundsSnap);
+                        return ret != 0;
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix)
+        {
+            float* snap = null;
+            float* localBounds = null;
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, snap, localBounds, boundsSnap);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix, ref float snap)
+        {
+            float* localBounds = null;
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            fixed (float* native_snap = &snap)
+                            {
+                                byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, native_snap, localBounds, boundsSnap);
+                                return ret != 0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds)
+        {
+            float* boundsSnap = null;
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            fixed (float* native_snap = &snap)
+                            {
+                                fixed (float* native_localBounds = &localBounds)
+                                {
+                                    byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, native_snap, native_localBounds, boundsSnap);
+                                    return ret != 0;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static bool Manipulate(ref float view, ref float projection, OPERATION operation, MODE mode, ref float matrix, ref float deltaMatrix, ref float snap, ref float localBounds, ref float boundsSnap)
+        {
+            fixed (float* native_view = &view)
+            {
+                fixed (float* native_projection = &projection)
+                {
+                    fixed (float* native_matrix = &matrix)
+                    {
+                        fixed (float* native_deltaMatrix = &deltaMatrix)
+                        {
+                            fixed (float* native_snap = &snap)
+                            {
+                                fixed (float* native_localBounds = &localBounds)
+                                {
+                                    fixed (float* native_boundsSnap = &boundsSnap)
+                                    {
+                                        byte ret = ImGuizmoNative.ImGuizmo_Manipulate(native_view, native_projection, operation, mode, native_matrix, native_deltaMatrix, native_snap, native_localBounds, native_boundsSnap);
+                                        return ret != 0;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public static void RecomposeMatrixFromComponents(ref float translation, ref float rotation, ref float scale, ref float matrix)
+        {
+            fixed (float* native_translation = &translation)
+            {
+                fixed (float* native_rotation = &rotation)
+                {
+                    fixed (float* native_scale = &scale)
+                    {
+                        fixed (float* native_matrix = &matrix)
+                        {
+                            ImGuizmoNative.ImGuizmo_RecomposeMatrixFromComponents(native_translation, native_rotation, native_scale, native_matrix);
+                        }
+                    }
+                }
+            }
+        }
+        public static void SetDrawlist()
+        {
+            ImDrawList* drawlist = null;
+            ImGuizmoNative.ImGuizmo_SetDrawlist(drawlist);
+        }
+        public static void SetDrawlist(ImDrawListPtr drawlist)
+        {
+            ImDrawList* native_drawlist = drawlist.NativePtr;
+            ImGuizmoNative.ImGuizmo_SetDrawlist(native_drawlist);
+        }
+        public static void SetGizmoSizeClipSpace(float value)
+        {
+            ImGuizmoNative.ImGuizmo_SetGizmoSizeClipSpace(value);
+        }
+        public static void SetID(int id)
+        {
+            ImGuizmoNative.ImGuizmo_SetID(id);
+        }
+        public static void SetImGuiContext(IntPtr ctx)
+        {
+            ImGuizmoNative.ImGuizmo_SetImGuiContext(ctx);
+        }
+        public static void SetOrthographic(bool isOrthographic)
+        {
+            byte native_isOrthographic = isOrthographic ? (byte)1 : (byte)0;
+            ImGuizmoNative.ImGuizmo_SetOrthographic(native_isOrthographic);
+        }
+        public static void SetRect(float x, float y, float width, float height)
+        {
+            ImGuizmoNative.ImGuizmo_SetRect(x, y, width, height);
+        }
+        public static void ViewManipulate(ref float view, float length, Vector2 position, Vector2 size, uint backgroundColor)
+        {
+            fixed (float* native_view = &view)
+            {
+                ImGuizmoNative.ImGuizmo_ViewManipulate(native_view, length, position, size, backgroundColor);
+            }
+        }
+    }
+}
diff --git a/src/ImGuizmo.NET/Generated/ImGuizmoNative.gen.cs b/src/ImGuizmo.NET/Generated/ImGuizmoNative.gen.cs
new file mode 100644
index 00000000..02ccef11
--- /dev/null
+++ b/src/ImGuizmo.NET/Generated/ImGuizmoNative.gen.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using ImGuiNET;
+
+namespace ImGuizmoNET
+{
+    public static unsafe partial class ImGuizmoNative
+    {
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_AllowAxisFlip(byte value);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_BeginFrame();
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_DecomposeMatrixToComponents(float* matrix, float* translation, float* rotation, float* scale);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_DrawCubes(float* view, float* projection, float* matrices, int matrixCount);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_DrawGrid(float* view, float* projection, float* matrix, float gridSize);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_Enable(byte enable);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_IsOverNil();
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_IsOverOPERATION(OPERATION op);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_IsUsing();
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImGuizmo_Manipulate(float* view, float* projection, OPERATION operation, MODE mode, float* matrix, float* deltaMatrix, float* snap, float* localBounds, float* boundsSnap);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_RecomposeMatrixFromComponents(float* translation, float* rotation, float* scale, float* matrix);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetDrawlist(ImDrawList* drawlist);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetGizmoSizeClipSpace(float value);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetID(int id);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetImGuiContext(IntPtr ctx);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetOrthographic(byte isOrthographic);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_SetRect(float x, float y, float width, float height);
+        [DllImport("cimguizmo", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImGuizmo_ViewManipulate(float* view, float length, Vector2 position, Vector2 size, uint backgroundColor);
+    }
+}
diff --git a/src/ImGuizmo.NET/Generated/MODE.gen.cs b/src/ImGuizmo.NET/Generated/MODE.gen.cs
new file mode 100644
index 00000000..c116b608
--- /dev/null
+++ b/src/ImGuizmo.NET/Generated/MODE.gen.cs
@@ -0,0 +1,8 @@
+namespace ImGuizmoNET
+{
+    public enum MODE
+    {
+        LOCAL = 0,
+        WORLD = 1,
+    }
+}
diff --git a/src/ImGuizmo.NET/Generated/OPERATION.gen.cs b/src/ImGuizmo.NET/Generated/OPERATION.gen.cs
new file mode 100644
index 00000000..8638162d
--- /dev/null
+++ b/src/ImGuizmo.NET/Generated/OPERATION.gen.cs
@@ -0,0 +1,20 @@
+namespace ImGuizmoNET
+{
+    public enum OPERATION
+    {
+        TRANSLATE_X = 1,
+        TRANSLATE_Y = 2,
+        TRANSLATE_Z = 4,
+        ROTATE_X = 8,
+        ROTATE_Y = 16,
+        ROTATE_Z = 32,
+        ROTATE_SCREEN = 64,
+        SCALE_X = 128,
+        SCALE_Y = 256,
+        SCALE_Z = 512,
+        BOUNDS = 1024,
+        TRANSLATE = 7,
+        ROTATE = 120,
+        SCALE = 896,
+    }
+}
diff --git a/src/ImGuizmo.NET/ImGuizmo.NET.csproj b/src/ImGuizmo.NET/ImGuizmo.NET.csproj
new file mode 100644
index 00000000..d2a2c9b4
--- /dev/null
+++ b/src/ImGuizmo.NET/ImGuizmo.NET.csproj
@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <Description>A .NET wrapper for the ImGuizmo library.</Description>
+    <AssemblyVersion>1.61.0</AssemblyVersion>
+    <Authors>Eric Mellino</Authors>
+    <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>portable</DebugType>
+    <AssemblyName>ImGuizmo.NET</AssemblyName>
+    <PackageId>ImGuizmo.NET</PackageId>
+    <PackagePrereleaseIdentifier></PackagePrereleaseIdentifier>
+    <PackageVersion>$(AssemblyVersion)$(PackagePrereleaseIdentifier)</PackageVersion>
+    <PackageTags>ImGuizmo ImGui ImGui.NET Immediate Mode GUI</PackageTags>
+    <PackageProjectUrl>https://github.com/mellinoe/imgui.net</PackageProjectUrl>
+    <DocumentationFile Condition="'$(Configuration)' == 'Release'">$(OutputPath)\ImGuizmo.NET.xml</DocumentationFile>
+    <RootNamespace>ImPlotNET</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <PackageReference Include="System.Buffers" Version="4.5.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ImGui.NET\ImGui.NET.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/ImNodes.NET/Generated/AttributeFlags.gen.cs b/src/ImNodes.NET/Generated/AttributeFlags.gen.cs
new file mode 100644
index 00000000..fdb4b969
--- /dev/null
+++ b/src/ImNodes.NET/Generated/AttributeFlags.gen.cs
@@ -0,0 +1,10 @@
+namespace imnodesNET
+{
+    [System.Flags]
+    public enum AttributeFlags
+    {
+        None = 0,
+        EnableLinkDetachWithDragClick = 1,
+        EnableLinkCreationOnSnap = 2,
+    }
+}
diff --git a/src/ImNodes.NET/Generated/ColorStyle.gen.cs b/src/ImNodes.NET/Generated/ColorStyle.gen.cs
new file mode 100644
index 00000000..c9ef51d6
--- /dev/null
+++ b/src/ImNodes.NET/Generated/ColorStyle.gen.cs
@@ -0,0 +1,23 @@
+namespace imnodesNET
+{
+    public enum ColorStyle
+    {
+        NodeBackground = 0,
+        NodeBackgroundHovered = 1,
+        NodeBackgroundSelected = 2,
+        NodeOutline = 3,
+        TitleBar = 4,
+        TitleBarHovered = 5,
+        TitleBarSelected = 6,
+        Link = 7,
+        LinkHovered = 8,
+        LinkSelected = 9,
+        Pin = 10,
+        PinHovered = 11,
+        BoxSelector = 12,
+        BoxSelectorOutline = 13,
+        GridBackground = 14,
+        GridLine = 15,
+        Count = 16,
+    }
+}
diff --git a/src/ImNodes.NET/Generated/EmulateThreeButtonMouse.gen.cs b/src/ImNodes.NET/Generated/EmulateThreeButtonMouse.gen.cs
new file mode 100644
index 00000000..0a213a47
--- /dev/null
+++ b/src/ImNodes.NET/Generated/EmulateThreeButtonMouse.gen.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace imnodesNET
+{
+    public unsafe partial struct EmulateThreeButtonMouse
+    {
+        public byte enabled;
+        public byte* modifier;
+    }
+    public unsafe partial struct EmulateThreeButtonMousePtr
+    {
+        public EmulateThreeButtonMouse* NativePtr { get; }
+        public EmulateThreeButtonMousePtr(EmulateThreeButtonMouse* nativePtr) => NativePtr = nativePtr;
+        public EmulateThreeButtonMousePtr(IntPtr nativePtr) => NativePtr = (EmulateThreeButtonMouse*)nativePtr;
+        public static implicit operator EmulateThreeButtonMousePtr(EmulateThreeButtonMouse* nativePtr) => new EmulateThreeButtonMousePtr(nativePtr);
+        public static implicit operator EmulateThreeButtonMouse* (EmulateThreeButtonMousePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator EmulateThreeButtonMousePtr(IntPtr nativePtr) => new EmulateThreeButtonMousePtr(nativePtr);
+        public ref bool enabled => ref Unsafe.AsRef<bool>(&NativePtr->enabled);
+        public IntPtr modifier { get => (IntPtr)NativePtr->modifier; set => NativePtr->modifier = (byte*)value; }
+        public void Destroy()
+        {
+            imnodesNative.EmulateThreeButtonMouse_destroy((EmulateThreeButtonMouse*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImNodes.NET/Generated/IO.gen.cs b/src/ImNodes.NET/Generated/IO.gen.cs
new file mode 100644
index 00000000..9c0b7746
--- /dev/null
+++ b/src/ImNodes.NET/Generated/IO.gen.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace imnodesNET
+{
+    public unsafe partial struct IO
+    {
+        public EmulateThreeButtonMouse emulate_three_button_mouse;
+        public LinkDetachWithModifierClick link_detach_with_modifier_click;
+    }
+    public unsafe partial struct IOPtr
+    {
+        public IO* NativePtr { get; }
+        public IOPtr(IO* nativePtr) => NativePtr = nativePtr;
+        public IOPtr(IntPtr nativePtr) => NativePtr = (IO*)nativePtr;
+        public static implicit operator IOPtr(IO* nativePtr) => new IOPtr(nativePtr);
+        public static implicit operator IO* (IOPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator IOPtr(IntPtr nativePtr) => new IOPtr(nativePtr);
+        public ref EmulateThreeButtonMouse emulate_three_button_mouse => ref Unsafe.AsRef<EmulateThreeButtonMouse>(&NativePtr->emulate_three_button_mouse);
+        public ref LinkDetachWithModifierClick link_detach_with_modifier_click => ref Unsafe.AsRef<LinkDetachWithModifierClick>(&NativePtr->link_detach_with_modifier_click);
+        public void Destroy()
+        {
+            imnodesNative.IO_destroy((IO*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImNodes.NET/Generated/ImNodes.gen.cs b/src/ImNodes.NET/Generated/ImNodes.gen.cs
new file mode 100644
index 00000000..89e9b4fc
--- /dev/null
+++ b/src/ImNodes.NET/Generated/ImNodes.gen.cs
@@ -0,0 +1,737 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+using ImGuiNET;
+
+namespace imnodesNET
+{
+    public static unsafe partial class imnodes
+    {
+        public static void BeginInputAttribute(int id)
+        {
+            PinShape shape = PinShape.CircleFilled;
+            imnodesNative.imnodes_BeginInputAttribute(id, shape);
+        }
+        public static void BeginInputAttribute(int id, PinShape shape)
+        {
+            imnodesNative.imnodes_BeginInputAttribute(id, shape);
+        }
+        public static void BeginNode(int id)
+        {
+            imnodesNative.imnodes_BeginNode(id);
+        }
+        public static void BeginNodeEditor()
+        {
+            imnodesNative.imnodes_BeginNodeEditor();
+        }
+        public static void BeginNodeTitleBar()
+        {
+            imnodesNative.imnodes_BeginNodeTitleBar();
+        }
+        public static void BeginOutputAttribute(int id)
+        {
+            PinShape shape = PinShape.CircleFilled;
+            imnodesNative.imnodes_BeginOutputAttribute(id, shape);
+        }
+        public static void BeginOutputAttribute(int id, PinShape shape)
+        {
+            imnodesNative.imnodes_BeginOutputAttribute(id, shape);
+        }
+        public static void BeginStaticAttribute(int id)
+        {
+            imnodesNative.imnodes_BeginStaticAttribute(id);
+        }
+        public static void ClearLinkSelection()
+        {
+            imnodesNative.imnodes_ClearLinkSelection();
+        }
+        public static void ClearNodeSelection()
+        {
+            imnodesNative.imnodes_ClearNodeSelection();
+        }
+        public static IntPtr EditorContextCreate()
+        {
+            IntPtr ret = imnodesNative.imnodes_EditorContextCreate();
+            return ret;
+        }
+        public static void EditorContextFree(IntPtr noname1)
+        {
+            imnodesNative.imnodes_EditorContextFree(noname1);
+        }
+        public static Vector2 EditorContextGetPanning()
+        {
+            Vector2 __retval;
+            imnodesNative.imnodes_EditorContextGetPanning(&__retval);
+            return __retval;
+        }
+        public static void EditorContextMoveToNode(int node_id)
+        {
+            imnodesNative.imnodes_EditorContextMoveToNode(node_id);
+        }
+        public static void EditorContextResetPanning(Vector2 pos)
+        {
+            imnodesNative.imnodes_EditorContextResetPanning(pos);
+        }
+        public static void EditorContextSet(IntPtr noname1)
+        {
+            imnodesNative.imnodes_EditorContextSet(noname1);
+        }
+        public static void EndInputAttribute()
+        {
+            imnodesNative.imnodes_EndInputAttribute();
+        }
+        public static void EndNode()
+        {
+            imnodesNative.imnodes_EndNode();
+        }
+        public static void EndNodeEditor()
+        {
+            imnodesNative.imnodes_EndNodeEditor();
+        }
+        public static void EndNodeTitleBar()
+        {
+            imnodesNative.imnodes_EndNodeTitleBar();
+        }
+        public static void EndOutputAttribute()
+        {
+            imnodesNative.imnodes_EndOutputAttribute();
+        }
+        public static void EndStaticAttribute()
+        {
+            imnodesNative.imnodes_EndStaticAttribute();
+        }
+        public static IO* GetIO()
+        {
+            IO* ret = imnodesNative.imnodes_GetIO();
+            return ret;
+        }
+        public static Vector2 GetNodeDimensions(int id)
+        {
+            Vector2 __retval;
+            imnodesNative.imnodes_GetNodeDimensions(&__retval, id);
+            return __retval;
+        }
+        public static Vector2 GetNodeEditorSpacePos(int node_id)
+        {
+            Vector2 __retval;
+            imnodesNative.imnodes_GetNodeEditorSpacePos(&__retval, node_id);
+            return __retval;
+        }
+        public static Vector2 GetNodeGridSpacePos(int node_id)
+        {
+            Vector2 __retval;
+            imnodesNative.imnodes_GetNodeGridSpacePos(&__retval, node_id);
+            return __retval;
+        }
+        public static Vector2 GetNodeScreenSpacePos(int node_id)
+        {
+            Vector2 __retval;
+            imnodesNative.imnodes_GetNodeScreenSpacePos(&__retval, node_id);
+            return __retval;
+        }
+        public static void GetSelectedLinks(ref int link_ids)
+        {
+            fixed (int* native_link_ids = &link_ids)
+            {
+                imnodesNative.imnodes_GetSelectedLinks(native_link_ids);
+            }
+        }
+        public static void GetSelectedNodes(ref int node_ids)
+        {
+            fixed (int* native_node_ids = &node_ids)
+            {
+                imnodesNative.imnodes_GetSelectedNodes(native_node_ids);
+            }
+        }
+        public static Style* GetStyle()
+        {
+            Style* ret = imnodesNative.imnodes_GetStyle();
+            return ret;
+        }
+        public static void Initialize()
+        {
+            imnodesNative.imnodes_Initialize();
+        }
+        public static bool IsAnyAttributeActive()
+        {
+            int* attribute_id = null;
+            byte ret = imnodesNative.imnodes_IsAnyAttributeActive(attribute_id);
+            return ret != 0;
+        }
+        public static bool IsAnyAttributeActive(ref int attribute_id)
+        {
+            fixed (int* native_attribute_id = &attribute_id)
+            {
+                byte ret = imnodesNative.imnodes_IsAnyAttributeActive(native_attribute_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsAttributeActive()
+        {
+            byte ret = imnodesNative.imnodes_IsAttributeActive();
+            return ret != 0;
+        }
+        public static bool IsEditorHovered()
+        {
+            byte ret = imnodesNative.imnodes_IsEditorHovered();
+            return ret != 0;
+        }
+        public static bool IsLinkCreated(ref int started_at_attribute_id, ref int ended_at_attribute_id)
+        {
+            byte* created_from_snap = null;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                {
+                    byte ret = imnodesNative.imnodes_IsLinkCreatedBoolPtr(native_started_at_attribute_id, native_ended_at_attribute_id, created_from_snap);
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool IsLinkCreated(ref int started_at_attribute_id, ref int ended_at_attribute_id, ref bool created_from_snap)
+        {
+            byte native_created_from_snap_val = created_from_snap ? (byte)1 : (byte)0;
+            byte* native_created_from_snap = &native_created_from_snap_val;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                {
+                    byte ret = imnodesNative.imnodes_IsLinkCreatedBoolPtr(native_started_at_attribute_id, native_ended_at_attribute_id, native_created_from_snap);
+                    created_from_snap = native_created_from_snap_val != 0;
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool IsLinkCreated(ref int started_at_node_id, ref int started_at_attribute_id, ref int ended_at_node_id, ref int ended_at_attribute_id)
+        {
+            byte* created_from_snap = null;
+            fixed (int* native_started_at_node_id = &started_at_node_id)
+            {
+                fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+                {
+                    fixed (int* native_ended_at_node_id = &ended_at_node_id)
+                    {
+                        fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                        {
+                            byte ret = imnodesNative.imnodes_IsLinkCreatedIntPtr(native_started_at_node_id, native_started_at_attribute_id, native_ended_at_node_id, native_ended_at_attribute_id, created_from_snap);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool IsLinkCreated(ref int started_at_node_id, ref int started_at_attribute_id, ref int ended_at_node_id, ref int ended_at_attribute_id, ref bool created_from_snap)
+        {
+            byte native_created_from_snap_val = created_from_snap ? (byte)1 : (byte)0;
+            byte* native_created_from_snap = &native_created_from_snap_val;
+            fixed (int* native_started_at_node_id = &started_at_node_id)
+            {
+                fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+                {
+                    fixed (int* native_ended_at_node_id = &ended_at_node_id)
+                    {
+                        fixed (int* native_ended_at_attribute_id = &ended_at_attribute_id)
+                        {
+                            byte ret = imnodesNative.imnodes_IsLinkCreatedIntPtr(native_started_at_node_id, native_started_at_attribute_id, native_ended_at_node_id, native_ended_at_attribute_id, native_created_from_snap);
+                            created_from_snap = native_created_from_snap_val != 0;
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool IsLinkDestroyed(ref int link_id)
+        {
+            fixed (int* native_link_id = &link_id)
+            {
+                byte ret = imnodesNative.imnodes_IsLinkDestroyed(native_link_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkDropped()
+        {
+            int* started_at_attribute_id = null;
+            byte including_detached_links = 1;
+            byte ret = imnodesNative.imnodes_IsLinkDropped(started_at_attribute_id, including_detached_links);
+            return ret != 0;
+        }
+        public static bool IsLinkDropped(ref int started_at_attribute_id)
+        {
+            byte including_detached_links = 1;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                byte ret = imnodesNative.imnodes_IsLinkDropped(native_started_at_attribute_id, including_detached_links);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkDropped(ref int started_at_attribute_id, bool including_detached_links)
+        {
+            byte native_including_detached_links = including_detached_links ? (byte)1 : (byte)0;
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                byte ret = imnodesNative.imnodes_IsLinkDropped(native_started_at_attribute_id, native_including_detached_links);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkHovered(ref int link_id)
+        {
+            fixed (int* native_link_id = &link_id)
+            {
+                byte ret = imnodesNative.imnodes_IsLinkHovered(native_link_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsLinkStarted(ref int started_at_attribute_id)
+        {
+            fixed (int* native_started_at_attribute_id = &started_at_attribute_id)
+            {
+                byte ret = imnodesNative.imnodes_IsLinkStarted(native_started_at_attribute_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsNodeHovered(ref int node_id)
+        {
+            fixed (int* native_node_id = &node_id)
+            {
+                byte ret = imnodesNative.imnodes_IsNodeHovered(native_node_id);
+                return ret != 0;
+            }
+        }
+        public static bool IsPinHovered(ref int attribute_id)
+        {
+            fixed (int* native_attribute_id = &attribute_id)
+            {
+                byte ret = imnodesNative.imnodes_IsPinHovered(native_attribute_id);
+                return ret != 0;
+            }
+        }
+        public static void Link(int id, int start_attribute_id, int end_attribute_id)
+        {
+            imnodesNative.imnodes_Link(id, start_attribute_id, end_attribute_id);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadCurrentEditorStateFromIniFile(ReadOnlySpan<char> file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_LoadCurrentEditorStateFromIniFile(native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+#endif
+        public static void LoadCurrentEditorStateFromIniFile(string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_LoadCurrentEditorStateFromIniFile(native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadCurrentEditorStateFromIniString(ReadOnlySpan<char> data, uint data_size)
+        {
+            byte* native_data;
+            int data_byteCount = 0;
+            if (data != null)
+            {
+                data_byteCount = Encoding.UTF8.GetByteCount(data);
+                if (data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_data = Util.Allocate(data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_data_stackBytes = stackalloc byte[data_byteCount + 1];
+                    native_data = native_data_stackBytes;
+                }
+                int native_data_offset = Util.GetUtf8(data, native_data, data_byteCount);
+                native_data[native_data_offset] = 0;
+            }
+            else { native_data = null; }
+            imnodesNative.imnodes_LoadCurrentEditorStateFromIniString(native_data, data_size);
+            if (data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_data);
+            }
+        }
+#endif
+        public static void LoadCurrentEditorStateFromIniString(string data, uint data_size)
+        {
+            byte* native_data;
+            int data_byteCount = 0;
+            if (data != null)
+            {
+                data_byteCount = Encoding.UTF8.GetByteCount(data);
+                if (data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_data = Util.Allocate(data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_data_stackBytes = stackalloc byte[data_byteCount + 1];
+                    native_data = native_data_stackBytes;
+                }
+                int native_data_offset = Util.GetUtf8(data, native_data, data_byteCount);
+                native_data[native_data_offset] = 0;
+            }
+            else { native_data = null; }
+            imnodesNative.imnodes_LoadCurrentEditorStateFromIniString(native_data, data_size);
+            if (data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_data);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadEditorStateFromIniFile(IntPtr editor, ReadOnlySpan<char> file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_LoadEditorStateFromIniFile(editor, native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+#endif
+        public static void LoadEditorStateFromIniFile(IntPtr editor, string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_LoadEditorStateFromIniFile(editor, native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void LoadEditorStateFromIniString(IntPtr editor, ReadOnlySpan<char> data, uint data_size)
+        {
+            byte* native_data;
+            int data_byteCount = 0;
+            if (data != null)
+            {
+                data_byteCount = Encoding.UTF8.GetByteCount(data);
+                if (data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_data = Util.Allocate(data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_data_stackBytes = stackalloc byte[data_byteCount + 1];
+                    native_data = native_data_stackBytes;
+                }
+                int native_data_offset = Util.GetUtf8(data, native_data, data_byteCount);
+                native_data[native_data_offset] = 0;
+            }
+            else { native_data = null; }
+            imnodesNative.imnodes_LoadEditorStateFromIniString(editor, native_data, data_size);
+            if (data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_data);
+            }
+        }
+#endif
+        public static void LoadEditorStateFromIniString(IntPtr editor, string data, uint data_size)
+        {
+            byte* native_data;
+            int data_byteCount = 0;
+            if (data != null)
+            {
+                data_byteCount = Encoding.UTF8.GetByteCount(data);
+                if (data_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_data = Util.Allocate(data_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_data_stackBytes = stackalloc byte[data_byteCount + 1];
+                    native_data = native_data_stackBytes;
+                }
+                int native_data_offset = Util.GetUtf8(data, native_data, data_byteCount);
+                native_data[native_data_offset] = 0;
+            }
+            else { native_data = null; }
+            imnodesNative.imnodes_LoadEditorStateFromIniString(editor, native_data, data_size);
+            if (data_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_data);
+            }
+        }
+        public static int NumSelectedLinks()
+        {
+            int ret = imnodesNative.imnodes_NumSelectedLinks();
+            return ret;
+        }
+        public static int NumSelectedNodes()
+        {
+            int ret = imnodesNative.imnodes_NumSelectedNodes();
+            return ret;
+        }
+        public static void PopAttributeFlag()
+        {
+            imnodesNative.imnodes_PopAttributeFlag();
+        }
+        public static void PopColorStyle()
+        {
+            imnodesNative.imnodes_PopColorStyle();
+        }
+        public static void PopStyleVar()
+        {
+            imnodesNative.imnodes_PopStyleVar();
+        }
+        public static void PushAttributeFlag(AttributeFlags flag)
+        {
+            imnodesNative.imnodes_PushAttributeFlag(flag);
+        }
+        public static void PushColorStyle(ColorStyle item, uint color)
+        {
+            imnodesNative.imnodes_PushColorStyle(item, color);
+        }
+        public static void PushStyleVar(StyleVar style_item, float value)
+        {
+            imnodesNative.imnodes_PushStyleVar(style_item, value);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SaveCurrentEditorStateToIniFile(ReadOnlySpan<char> file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_SaveCurrentEditorStateToIniFile(native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+#endif
+        public static void SaveCurrentEditorStateToIniFile(string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_SaveCurrentEditorStateToIniFile(native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+        public static string SaveCurrentEditorStateToIniString()
+        {
+            uint* data_size = null;
+            byte* ret = imnodesNative.imnodes_SaveCurrentEditorStateToIniString(data_size);
+            return Util.StringFromPtr(ret);
+        }
+        public static string SaveCurrentEditorStateToIniString(ref uint data_size)
+        {
+            fixed (uint* native_data_size = &data_size)
+            {
+                byte* ret = imnodesNative.imnodes_SaveCurrentEditorStateToIniString(native_data_size);
+                return Util.StringFromPtr(ret);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SaveEditorStateToIniFile(IntPtr editor, ReadOnlySpan<char> file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_SaveEditorStateToIniFile(editor, native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+#endif
+        public static void SaveEditorStateToIniFile(IntPtr editor, string file_name)
+        {
+            byte* native_file_name;
+            int file_name_byteCount = 0;
+            if (file_name != null)
+            {
+                file_name_byteCount = Encoding.UTF8.GetByteCount(file_name);
+                if (file_name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_file_name = Util.Allocate(file_name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_file_name_stackBytes = stackalloc byte[file_name_byteCount + 1];
+                    native_file_name = native_file_name_stackBytes;
+                }
+                int native_file_name_offset = Util.GetUtf8(file_name, native_file_name, file_name_byteCount);
+                native_file_name[native_file_name_offset] = 0;
+            }
+            else { native_file_name = null; }
+            imnodesNative.imnodes_SaveEditorStateToIniFile(editor, native_file_name);
+            if (file_name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_file_name);
+            }
+        }
+        public static string SaveEditorStateToIniString(IntPtr editor)
+        {
+            uint* data_size = null;
+            byte* ret = imnodesNative.imnodes_SaveEditorStateToIniString(editor, data_size);
+            return Util.StringFromPtr(ret);
+        }
+        public static string SaveEditorStateToIniString(IntPtr editor, ref uint data_size)
+        {
+            fixed (uint* native_data_size = &data_size)
+            {
+                byte* ret = imnodesNative.imnodes_SaveEditorStateToIniString(editor, native_data_size);
+                return Util.StringFromPtr(ret);
+            }
+        }
+        public static void SetImGuiContext(IntPtr ctx)
+        {
+            imnodesNative.imnodes_SetImGuiContext(ctx);
+        }
+        public static void SetNodeDraggable(int node_id, bool draggable)
+        {
+            byte native_draggable = draggable ? (byte)1 : (byte)0;
+            imnodesNative.imnodes_SetNodeDraggable(node_id, native_draggable);
+        }
+        public static void SetNodeEditorSpacePos(int node_id, Vector2 editor_space_pos)
+        {
+            imnodesNative.imnodes_SetNodeEditorSpacePos(node_id, editor_space_pos);
+        }
+        public static void SetNodeGridSpacePos(int node_id, Vector2 grid_pos)
+        {
+            imnodesNative.imnodes_SetNodeGridSpacePos(node_id, grid_pos);
+        }
+        public static void SetNodeScreenSpacePos(int node_id, Vector2 screen_space_pos)
+        {
+            imnodesNative.imnodes_SetNodeScreenSpacePos(node_id, screen_space_pos);
+        }
+        public static void Shutdown()
+        {
+            imnodesNative.imnodes_Shutdown();
+        }
+        public static void StyleColorsClassic()
+        {
+            imnodesNative.imnodes_StyleColorsClassic();
+        }
+        public static void StyleColorsDark()
+        {
+            imnodesNative.imnodes_StyleColorsDark();
+        }
+        public static void StyleColorsLight()
+        {
+            imnodesNative.imnodes_StyleColorsLight();
+        }
+    }
+}
diff --git a/src/ImNodes.NET/Generated/ImNodesNative.gen.cs b/src/ImNodes.NET/Generated/ImNodesNative.gen.cs
new file mode 100644
index 00000000..d2e65525
--- /dev/null
+++ b/src/ImNodes.NET/Generated/ImNodesNative.gen.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using ImGuiNET;
+
+namespace imnodesNET
+{
+    public static unsafe partial class imnodesNative
+    {
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void EmulateThreeButtonMouse_destroy(EmulateThreeButtonMouse* self);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern EmulateThreeButtonMouse* EmulateThreeButtonMouse_EmulateThreeButtonMouse();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginInputAttribute(int id, PinShape shape);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginNode(int id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginNodeEditor();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginNodeTitleBar();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginOutputAttribute(int id, PinShape shape);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_BeginStaticAttribute(int id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_ClearLinkSelection();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_ClearNodeSelection();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr imnodes_EditorContextCreate();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextFree(IntPtr noname1);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextGetPanning(Vector2* pOut);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextMoveToNode(int node_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextResetPanning(Vector2 pos);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EditorContextSet(IntPtr noname1);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndInputAttribute();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndNode();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndNodeEditor();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndNodeTitleBar();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndOutputAttribute();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_EndStaticAttribute();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IO* imnodes_GetIO();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeDimensions(Vector2* pOut, int id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeEditorSpacePos(Vector2* pOut, int node_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeGridSpacePos(Vector2* pOut, int node_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetNodeScreenSpacePos(Vector2* pOut, int node_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetSelectedLinks(int* link_ids);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_GetSelectedNodes(int* node_ids);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern Style* imnodes_GetStyle();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_Initialize();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsAnyAttributeActive(int* attribute_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsAttributeActive();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsEditorHovered();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkCreatedBoolPtr(int* started_at_attribute_id, int* ended_at_attribute_id, byte* created_from_snap);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkCreatedIntPtr(int* started_at_node_id, int* started_at_attribute_id, int* ended_at_node_id, int* ended_at_attribute_id, byte* created_from_snap);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkDestroyed(int* link_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkDropped(int* started_at_attribute_id, byte including_detached_links);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkHovered(int* link_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsLinkStarted(int* started_at_attribute_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsNodeHovered(int* node_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte imnodes_IsPinHovered(int* attribute_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_Link(int id, int start_attribute_id, int end_attribute_id);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadCurrentEditorStateFromIniFile(byte* file_name);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadCurrentEditorStateFromIniString(byte* data, uint data_size);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadEditorStateFromIniFile(IntPtr editor, byte* file_name);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_LoadEditorStateFromIniString(IntPtr editor, byte* data, uint data_size);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int imnodes_NumSelectedLinks();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int imnodes_NumSelectedNodes();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PopAttributeFlag();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PopColorStyle();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PopStyleVar();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PushAttributeFlag(AttributeFlags flag);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PushColorStyle(ColorStyle item, uint color);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_PushStyleVar(StyleVar style_item, float value);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SaveCurrentEditorStateToIniFile(byte* file_name);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* imnodes_SaveCurrentEditorStateToIniString(uint* data_size);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SaveEditorStateToIniFile(IntPtr editor, byte* file_name);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* imnodes_SaveEditorStateToIniString(IntPtr editor, uint* data_size);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetImGuiContext(IntPtr ctx);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeDraggable(int node_id, byte draggable);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeEditorSpacePos(int node_id, Vector2 editor_space_pos);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeGridSpacePos(int node_id, Vector2 grid_pos);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_SetNodeScreenSpacePos(int node_id, Vector2 screen_space_pos);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_Shutdown();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_StyleColorsClassic();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_StyleColorsDark();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void imnodes_StyleColorsLight();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void IO_destroy(IO* self);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IO* IO_IO();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void LinkDetachWithModifierClick_destroy(LinkDetachWithModifierClick* self);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern LinkDetachWithModifierClick* LinkDetachWithModifierClick_LinkDetachWithModifierClick();
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void Style_destroy(Style* self);
+        [DllImport("cimnodes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern Style* Style_Style();
+    }
+}
diff --git a/src/ImNodes.NET/Generated/LinkDetachWithModifierClick.gen.cs b/src/ImNodes.NET/Generated/LinkDetachWithModifierClick.gen.cs
new file mode 100644
index 00000000..0424b41c
--- /dev/null
+++ b/src/ImNodes.NET/Generated/LinkDetachWithModifierClick.gen.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace imnodesNET
+{
+    public unsafe partial struct LinkDetachWithModifierClick
+    {
+        public byte* modifier;
+    }
+    public unsafe partial struct LinkDetachWithModifierClickPtr
+    {
+        public LinkDetachWithModifierClick* NativePtr { get; }
+        public LinkDetachWithModifierClickPtr(LinkDetachWithModifierClick* nativePtr) => NativePtr = nativePtr;
+        public LinkDetachWithModifierClickPtr(IntPtr nativePtr) => NativePtr = (LinkDetachWithModifierClick*)nativePtr;
+        public static implicit operator LinkDetachWithModifierClickPtr(LinkDetachWithModifierClick* nativePtr) => new LinkDetachWithModifierClickPtr(nativePtr);
+        public static implicit operator LinkDetachWithModifierClick* (LinkDetachWithModifierClickPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator LinkDetachWithModifierClickPtr(IntPtr nativePtr) => new LinkDetachWithModifierClickPtr(nativePtr);
+        public IntPtr modifier { get => (IntPtr)NativePtr->modifier; set => NativePtr->modifier = (byte*)value; }
+        public void Destroy()
+        {
+            imnodesNative.LinkDetachWithModifierClick_destroy((LinkDetachWithModifierClick*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImNodes.NET/Generated/PinShape.gen.cs b/src/ImNodes.NET/Generated/PinShape.gen.cs
new file mode 100644
index 00000000..fd0fd0dc
--- /dev/null
+++ b/src/ImNodes.NET/Generated/PinShape.gen.cs
@@ -0,0 +1,12 @@
+namespace imnodesNET
+{
+    public enum PinShape
+    {
+        Circle = 0,
+        CircleFilled = 1,
+        Triangle = 2,
+        TriangleFilled = 3,
+        Quad = 4,
+        QuadFilled = 5,
+    }
+}
diff --git a/src/ImNodes.NET/Generated/Style.gen.cs b/src/ImNodes.NET/Generated/Style.gen.cs
new file mode 100644
index 00000000..81ea16b5
--- /dev/null
+++ b/src/ImNodes.NET/Generated/Style.gen.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace imnodesNET
+{
+    public unsafe partial struct Style
+    {
+        public float grid_spacing;
+        public float node_corner_rounding;
+        public float node_padding_horizontal;
+        public float node_padding_vertical;
+        public float node_border_thickness;
+        public float link_thickness;
+        public float link_line_segments_per_length;
+        public float link_hover_distance;
+        public float pin_circle_radius;
+        public float pin_quad_side_length;
+        public float pin_triangle_side_length;
+        public float pin_line_thickness;
+        public float pin_hover_radius;
+        public float pin_offset;
+        public StyleFlags flags;
+        public fixed uint colors[16];
+    }
+    public unsafe partial struct StylePtr
+    {
+        public Style* NativePtr { get; }
+        public StylePtr(Style* nativePtr) => NativePtr = nativePtr;
+        public StylePtr(IntPtr nativePtr) => NativePtr = (Style*)nativePtr;
+        public static implicit operator StylePtr(Style* nativePtr) => new StylePtr(nativePtr);
+        public static implicit operator Style* (StylePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator StylePtr(IntPtr nativePtr) => new StylePtr(nativePtr);
+        public ref float grid_spacing => ref Unsafe.AsRef<float>(&NativePtr->grid_spacing);
+        public ref float node_corner_rounding => ref Unsafe.AsRef<float>(&NativePtr->node_corner_rounding);
+        public ref float node_padding_horizontal => ref Unsafe.AsRef<float>(&NativePtr->node_padding_horizontal);
+        public ref float node_padding_vertical => ref Unsafe.AsRef<float>(&NativePtr->node_padding_vertical);
+        public ref float node_border_thickness => ref Unsafe.AsRef<float>(&NativePtr->node_border_thickness);
+        public ref float link_thickness => ref Unsafe.AsRef<float>(&NativePtr->link_thickness);
+        public ref float link_line_segments_per_length => ref Unsafe.AsRef<float>(&NativePtr->link_line_segments_per_length);
+        public ref float link_hover_distance => ref Unsafe.AsRef<float>(&NativePtr->link_hover_distance);
+        public ref float pin_circle_radius => ref Unsafe.AsRef<float>(&NativePtr->pin_circle_radius);
+        public ref float pin_quad_side_length => ref Unsafe.AsRef<float>(&NativePtr->pin_quad_side_length);
+        public ref float pin_triangle_side_length => ref Unsafe.AsRef<float>(&NativePtr->pin_triangle_side_length);
+        public ref float pin_line_thickness => ref Unsafe.AsRef<float>(&NativePtr->pin_line_thickness);
+        public ref float pin_hover_radius => ref Unsafe.AsRef<float>(&NativePtr->pin_hover_radius);
+        public ref float pin_offset => ref Unsafe.AsRef<float>(&NativePtr->pin_offset);
+        public ref StyleFlags flags => ref Unsafe.AsRef<StyleFlags>(&NativePtr->flags);
+        public RangeAccessor<uint> colors => new RangeAccessor<uint>(NativePtr->colors, 16);
+        public void Destroy()
+        {
+            imnodesNative.Style_destroy((Style*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImNodes.NET/Generated/StyleFlags.gen.cs b/src/ImNodes.NET/Generated/StyleFlags.gen.cs
new file mode 100644
index 00000000..ec6644e5
--- /dev/null
+++ b/src/ImNodes.NET/Generated/StyleFlags.gen.cs
@@ -0,0 +1,10 @@
+namespace imnodesNET
+{
+    [System.Flags]
+    public enum StyleFlags
+    {
+        None = 0,
+        NodeOutline = 1,
+        GridLines = 4,
+    }
+}
diff --git a/src/ImNodes.NET/Generated/StyleVar.gen.cs b/src/ImNodes.NET/Generated/StyleVar.gen.cs
new file mode 100644
index 00000000..cb5df3ce
--- /dev/null
+++ b/src/ImNodes.NET/Generated/StyleVar.gen.cs
@@ -0,0 +1,20 @@
+namespace imnodesNET
+{
+    public enum StyleVar
+    {
+        GridSpacing = 0,
+        NodeCornerRounding = 1,
+        NodePaddingHorizontal = 2,
+        NodePaddingVertical = 3,
+        NodeBorderThickness = 4,
+        LinkThickness = 5,
+        LinkLineSegmentsPerLength = 6,
+        LinkHoverDistance = 7,
+        PinCircleRadius = 8,
+        PinQuadSideLength = 9,
+        PinTriangleSideLength = 10,
+        PinLineThickness = 11,
+        PinHoverRadius = 12,
+        PinOffset = 13,
+    }
+}
diff --git a/src/ImNodes.NET/ImNodes.NET.csproj b/src/ImNodes.NET/ImNodes.NET.csproj
new file mode 100644
index 00000000..4446a9df
--- /dev/null
+++ b/src/ImNodes.NET/ImNodes.NET.csproj
@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <Description>A .NET wrapper for the imnodes library.</Description>
+    <AssemblyVersion>0.3.0</AssemblyVersion>
+    <Authors>Eric Mellino</Authors>
+    <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>portable</DebugType>
+    <AssemblyName>ImNodes.NET</AssemblyName>
+    <PackageId>ImNodes.NET</PackageId>
+    <PackagePrereleaseIdentifier></PackagePrereleaseIdentifier>
+    <PackageVersion>$(AssemblyVersion)$(PackagePrereleaseIdentifier)</PackageVersion>
+    <PackageTags>imnodes ImGui ImGui.NET Immediate Mode GUI</PackageTags>
+    <PackageProjectUrl>https://github.com/mellinoe/imgui.net</PackageProjectUrl>
+    <DocumentationFile Condition="'$(Configuration)' == 'Release'">$(OutputPath)\imnodes.NET.xml</DocumentationFile>
+    <RootNamespace>imnodesNET</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <PackageReference Include="System.Buffers" Version="4.5.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ImGui.NET\ImGui.NET.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/ImPlot.NET/Generated/ImAxis.gen.cs b/src/ImPlot.NET/Generated/ImAxis.gen.cs
new file mode 100644
index 00000000..2e4c7ae0
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImAxis.gen.cs
@@ -0,0 +1,13 @@
+namespace ImPlotNET
+{
+    public enum ImAxis
+    {
+        X1 = 0,
+        X2 = 1,
+        X3 = 2,
+        Y1 = 3,
+        Y2 = 4,
+        Y3 = 5,
+        COUNT = 6,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlot.gen.cs b/src/ImPlot.NET/Generated/ImPlot.gen.cs
new file mode 100644
index 00000000..cb0ba801
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlot.gen.cs
@@ -0,0 +1,82168 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public static unsafe partial class ImPlot
+    {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImPlotColormap AddColormap(ReadOnlySpan<char> name, ref Vector4 cols, int size)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte qual = 1;
+            fixed (Vector4* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_Vec4Ptr(native_name, native_cols, size, qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static ImPlotColormap AddColormap(string name, ref Vector4 cols, int size)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte qual = 1;
+            fixed (Vector4* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_Vec4Ptr(native_name, native_cols, size, qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImPlotColormap AddColormap(ReadOnlySpan<char> name, ref Vector4 cols, int size, bool qual)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_qual = qual ? (byte)1 : (byte)0;
+            fixed (Vector4* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_Vec4Ptr(native_name, native_cols, size, native_qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static ImPlotColormap AddColormap(string name, ref Vector4 cols, int size, bool qual)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_qual = qual ? (byte)1 : (byte)0;
+            fixed (Vector4* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_Vec4Ptr(native_name, native_cols, size, native_qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImPlotColormap AddColormap(ReadOnlySpan<char> name, ref uint cols, int size)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte qual = 1;
+            fixed (uint* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_U32Ptr(native_name, native_cols, size, qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static ImPlotColormap AddColormap(string name, ref uint cols, int size)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte qual = 1;
+            fixed (uint* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_U32Ptr(native_name, native_cols, size, qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImPlotColormap AddColormap(ReadOnlySpan<char> name, ref uint cols, int size, bool qual)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_qual = qual ? (byte)1 : (byte)0;
+            fixed (uint* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_U32Ptr(native_name, native_cols, size, native_qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static ImPlotColormap AddColormap(string name, ref uint cols, int size, bool qual)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            byte native_qual = qual ? (byte)1 : (byte)0;
+            fixed (uint* native_cols = &cols)
+            {
+                ImPlotColormap ret = ImPlotNative.ImPlot_AddColormap_U32Ptr(native_name, native_cols, size, native_qual);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_name);
+                }
+                return ret;
+            }
+        }
+        public static void Annotation(double x, double y, Vector4 col, Vector2 pix_offset, bool clamp)
+        {
+            byte native_clamp = clamp ? (byte)1 : (byte)0;
+            byte round = 0;
+            ImPlotNative.ImPlot_Annotation_Bool(x, y, col, pix_offset, native_clamp, round);
+        }
+        public static void Annotation(double x, double y, Vector4 col, Vector2 pix_offset, bool clamp, bool round)
+        {
+            byte native_clamp = clamp ? (byte)1 : (byte)0;
+            byte native_round = round ? (byte)1 : (byte)0;
+            ImPlotNative.ImPlot_Annotation_Bool(x, y, col, pix_offset, native_clamp, native_round);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void Annotation(double x, double y, Vector4 col, Vector2 pix_offset, bool clamp, ReadOnlySpan<char> fmt)
+        {
+            byte native_clamp = clamp ? (byte)1 : (byte)0;
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_Annotation_Str(x, y, col, pix_offset, native_clamp, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void Annotation(double x, double y, Vector4 col, Vector2 pix_offset, bool clamp, string fmt)
+        {
+            byte native_clamp = clamp ? (byte)1 : (byte)0;
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_Annotation_Str(x, y, col, pix_offset, native_clamp, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginAlignedPlots(ReadOnlySpan<char> group_id)
+        {
+            byte* native_group_id;
+            int group_id_byteCount = 0;
+            if (group_id != null)
+            {
+                group_id_byteCount = Encoding.UTF8.GetByteCount(group_id);
+                if (group_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_group_id = Util.Allocate(group_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_group_id_stackBytes = stackalloc byte[group_id_byteCount + 1];
+                    native_group_id = native_group_id_stackBytes;
+                }
+                int native_group_id_offset = Util.GetUtf8(group_id, native_group_id, group_id_byteCount);
+                native_group_id[native_group_id_offset] = 0;
+            }
+            else { native_group_id = null; }
+            byte vertical = 1;
+            byte ret = ImPlotNative.ImPlot_BeginAlignedPlots(native_group_id, vertical);
+            if (group_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_group_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginAlignedPlots(string group_id)
+        {
+            byte* native_group_id;
+            int group_id_byteCount = 0;
+            if (group_id != null)
+            {
+                group_id_byteCount = Encoding.UTF8.GetByteCount(group_id);
+                if (group_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_group_id = Util.Allocate(group_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_group_id_stackBytes = stackalloc byte[group_id_byteCount + 1];
+                    native_group_id = native_group_id_stackBytes;
+                }
+                int native_group_id_offset = Util.GetUtf8(group_id, native_group_id, group_id_byteCount);
+                native_group_id[native_group_id_offset] = 0;
+            }
+            else { native_group_id = null; }
+            byte vertical = 1;
+            byte ret = ImPlotNative.ImPlot_BeginAlignedPlots(native_group_id, vertical);
+            if (group_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_group_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginAlignedPlots(ReadOnlySpan<char> group_id, bool vertical)
+        {
+            byte* native_group_id;
+            int group_id_byteCount = 0;
+            if (group_id != null)
+            {
+                group_id_byteCount = Encoding.UTF8.GetByteCount(group_id);
+                if (group_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_group_id = Util.Allocate(group_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_group_id_stackBytes = stackalloc byte[group_id_byteCount + 1];
+                    native_group_id = native_group_id_stackBytes;
+                }
+                int native_group_id_offset = Util.GetUtf8(group_id, native_group_id, group_id_byteCount);
+                native_group_id[native_group_id_offset] = 0;
+            }
+            else { native_group_id = null; }
+            byte native_vertical = vertical ? (byte)1 : (byte)0;
+            byte ret = ImPlotNative.ImPlot_BeginAlignedPlots(native_group_id, native_vertical);
+            if (group_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_group_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginAlignedPlots(string group_id, bool vertical)
+        {
+            byte* native_group_id;
+            int group_id_byteCount = 0;
+            if (group_id != null)
+            {
+                group_id_byteCount = Encoding.UTF8.GetByteCount(group_id);
+                if (group_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_group_id = Util.Allocate(group_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_group_id_stackBytes = stackalloc byte[group_id_byteCount + 1];
+                    native_group_id = native_group_id_stackBytes;
+                }
+                int native_group_id_offset = Util.GetUtf8(group_id, native_group_id, group_id_byteCount);
+                native_group_id[native_group_id_offset] = 0;
+            }
+            else { native_group_id = null; }
+            byte native_vertical = vertical ? (byte)1 : (byte)0;
+            byte ret = ImPlotNative.ImPlot_BeginAlignedPlots(native_group_id, native_vertical);
+            if (group_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_group_id);
+            }
+            return ret != 0;
+        }
+        public static bool BeginDragDropSourceAxis(ImAxis axis)
+        {
+            ImGuiDragDropFlags flags = 0;
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourceAxis(axis, flags);
+            return ret != 0;
+        }
+        public static bool BeginDragDropSourceAxis(ImAxis axis, ImGuiDragDropFlags flags)
+        {
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourceAxis(axis, flags);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginDragDropSourceItem(ReadOnlySpan<char> label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImGuiDragDropFlags flags = 0;
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourceItem(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginDragDropSourceItem(string label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImGuiDragDropFlags flags = 0;
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourceItem(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginDragDropSourceItem(ReadOnlySpan<char> label_id, ImGuiDragDropFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourceItem(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginDragDropSourceItem(string label_id, ImGuiDragDropFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourceItem(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+        public static bool BeginDragDropSourcePlot()
+        {
+            ImGuiDragDropFlags flags = 0;
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourcePlot(flags);
+            return ret != 0;
+        }
+        public static bool BeginDragDropSourcePlot(ImGuiDragDropFlags flags)
+        {
+            byte ret = ImPlotNative.ImPlot_BeginDragDropSourcePlot(flags);
+            return ret != 0;
+        }
+        public static bool BeginDragDropTargetAxis(ImAxis axis)
+        {
+            byte ret = ImPlotNative.ImPlot_BeginDragDropTargetAxis(axis);
+            return ret != 0;
+        }
+        public static bool BeginDragDropTargetLegend()
+        {
+            byte ret = ImPlotNative.ImPlot_BeginDragDropTargetLegend();
+            return ret != 0;
+        }
+        public static bool BeginDragDropTargetPlot()
+        {
+            byte ret = ImPlotNative.ImPlot_BeginDragDropTargetPlot();
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginLegendPopup(ReadOnlySpan<char> label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImGuiMouseButton mouse_button = (ImGuiMouseButton)1;
+            byte ret = ImPlotNative.ImPlot_BeginLegendPopup(native_label_id, mouse_button);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginLegendPopup(string label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImGuiMouseButton mouse_button = (ImGuiMouseButton)1;
+            byte ret = ImPlotNative.ImPlot_BeginLegendPopup(native_label_id, mouse_button);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginLegendPopup(ReadOnlySpan<char> label_id, ImGuiMouseButton mouse_button)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte ret = ImPlotNative.ImPlot_BeginLegendPopup(native_label_id, mouse_button);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginLegendPopup(string label_id, ImGuiMouseButton mouse_button)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte ret = ImPlotNative.ImPlot_BeginLegendPopup(native_label_id, mouse_button);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPlot(ReadOnlySpan<char> title_id)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            Vector2 size = new Vector2(-1, 0);
+            ImPlotFlags flags = (ImPlotFlags)0;
+            byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, size, flags);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginPlot(string title_id)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            Vector2 size = new Vector2(-1, 0);
+            ImPlotFlags flags = (ImPlotFlags)0;
+            byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, size, flags);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPlot(ReadOnlySpan<char> title_id, Vector2 size)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            ImPlotFlags flags = (ImPlotFlags)0;
+            byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, size, flags);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginPlot(string title_id, Vector2 size)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            ImPlotFlags flags = (ImPlotFlags)0;
+            byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, size, flags);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginPlot(ReadOnlySpan<char> title_id, Vector2 size, ImPlotFlags flags)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, size, flags);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginPlot(string title_id, Vector2 size, ImPlotFlags flags)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            byte ret = ImPlotNative.ImPlot_BeginPlot(native_title_id, size, flags);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginSubplots(ReadOnlySpan<char> title_id, int rows, int cols, Vector2 size)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            ImPlotSubplotFlags flags = (ImPlotSubplotFlags)0;
+            float* row_ratios = null;
+            float* col_ratios = null;
+            byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, row_ratios, col_ratios);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginSubplots(string title_id, int rows, int cols, Vector2 size)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            ImPlotSubplotFlags flags = (ImPlotSubplotFlags)0;
+            float* row_ratios = null;
+            float* col_ratios = null;
+            byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, row_ratios, col_ratios);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginSubplots(ReadOnlySpan<char> title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            float* row_ratios = null;
+            float* col_ratios = null;
+            byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, row_ratios, col_ratios);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool BeginSubplots(string title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            float* row_ratios = null;
+            float* col_ratios = null;
+            byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, row_ratios, col_ratios);
+            if (title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_title_id);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginSubplots(ReadOnlySpan<char> title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float row_ratios)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            float* col_ratios = null;
+            fixed (float* native_row_ratios = &row_ratios)
+            {
+                byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, native_row_ratios, col_ratios);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_title_id);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool BeginSubplots(string title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float row_ratios)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            float* col_ratios = null;
+            fixed (float* native_row_ratios = &row_ratios)
+            {
+                byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, native_row_ratios, col_ratios);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_title_id);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool BeginSubplots(ReadOnlySpan<char> title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float row_ratios, ref float col_ratios)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            fixed (float* native_row_ratios = &row_ratios)
+            {
+                fixed (float* native_col_ratios = &col_ratios)
+                {
+                    byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, native_row_ratios, native_col_ratios);
+                    if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_title_id);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool BeginSubplots(string title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float row_ratios, ref float col_ratios)
+        {
+            byte* native_title_id;
+            int title_id_byteCount = 0;
+            if (title_id != null)
+            {
+                title_id_byteCount = Encoding.UTF8.GetByteCount(title_id);
+                if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_title_id = Util.Allocate(title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_title_id_stackBytes = stackalloc byte[title_id_byteCount + 1];
+                    native_title_id = native_title_id_stackBytes;
+                }
+                int native_title_id_offset = Util.GetUtf8(title_id, native_title_id, title_id_byteCount);
+                native_title_id[native_title_id_offset] = 0;
+            }
+            else { native_title_id = null; }
+            fixed (float* native_row_ratios = &row_ratios)
+            {
+                fixed (float* native_col_ratios = &col_ratios)
+                {
+                    byte ret = ImPlotNative.ImPlot_BeginSubplots(native_title_id, rows, cols, size, flags, native_row_ratios, native_col_ratios);
+                    if (title_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_title_id);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+        public static void BustColorCache()
+        {
+            byte* native_plot_title_id = null;
+            ImPlotNative.ImPlot_BustColorCache(native_plot_title_id);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void BustColorCache(ReadOnlySpan<char> plot_title_id)
+        {
+            byte* native_plot_title_id;
+            int plot_title_id_byteCount = 0;
+            if (plot_title_id != null)
+            {
+                plot_title_id_byteCount = Encoding.UTF8.GetByteCount(plot_title_id);
+                if (plot_title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_plot_title_id = Util.Allocate(plot_title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_plot_title_id_stackBytes = stackalloc byte[plot_title_id_byteCount + 1];
+                    native_plot_title_id = native_plot_title_id_stackBytes;
+                }
+                int native_plot_title_id_offset = Util.GetUtf8(plot_title_id, native_plot_title_id, plot_title_id_byteCount);
+                native_plot_title_id[native_plot_title_id_offset] = 0;
+            }
+            else { native_plot_title_id = null; }
+            ImPlotNative.ImPlot_BustColorCache(native_plot_title_id);
+            if (plot_title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_plot_title_id);
+            }
+        }
+#endif
+        public static void BustColorCache(string plot_title_id)
+        {
+            byte* native_plot_title_id;
+            int plot_title_id_byteCount = 0;
+            if (plot_title_id != null)
+            {
+                plot_title_id_byteCount = Encoding.UTF8.GetByteCount(plot_title_id);
+                if (plot_title_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_plot_title_id = Util.Allocate(plot_title_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_plot_title_id_stackBytes = stackalloc byte[plot_title_id_byteCount + 1];
+                    native_plot_title_id = native_plot_title_id_stackBytes;
+                }
+                int native_plot_title_id_offset = Util.GetUtf8(plot_title_id, native_plot_title_id, plot_title_id_byteCount);
+                native_plot_title_id[native_plot_title_id_offset] = 0;
+            }
+            else { native_plot_title_id = null; }
+            ImPlotNative.ImPlot_BustColorCache(native_plot_title_id);
+            if (plot_title_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_plot_title_id);
+            }
+        }
+        public static void CancelPlotSelection()
+        {
+            ImPlotNative.ImPlot_CancelPlotSelection();
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapButton(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            Vector2 size = new Vector2();
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            byte ret = ImPlotNative.ImPlot_ColormapButton(native_label, size, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ColormapButton(string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            Vector2 size = new Vector2();
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            byte ret = ImPlotNative.ImPlot_ColormapButton(native_label, size, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapButton(ReadOnlySpan<char> label, Vector2 size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            byte ret = ImPlotNative.ImPlot_ColormapButton(native_label, size, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ColormapButton(string label, Vector2 size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            byte ret = ImPlotNative.ImPlot_ColormapButton(native_label, size, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapButton(ReadOnlySpan<char> label, Vector2 size, ImPlotColormap cmap)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ColormapButton(native_label, size, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ColormapButton(string label, Vector2 size, ImPlotColormap cmap)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ColormapButton(native_label, size, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+        public static void ColormapIcon(ImPlotColormap cmap)
+        {
+            ImPlotNative.ImPlot_ColormapIcon(cmap);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ColormapScale(ReadOnlySpan<char> label, double scale_min, double scale_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            Vector2 size = new Vector2();
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%g");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%g", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormapScaleFlags flags = (ImPlotColormapScaleFlags)0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#endif
+        public static void ColormapScale(string label, double scale_min, double scale_max)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            Vector2 size = new Vector2();
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%g");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%g", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormapScaleFlags flags = (ImPlotColormapScaleFlags)0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ColormapScale(ReadOnlySpan<char> label, double scale_min, double scale_max, Vector2 size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%g");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%g", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormapScaleFlags flags = (ImPlotColormapScaleFlags)0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#endif
+        public static void ColormapScale(string label, double scale_min, double scale_max, Vector2 size)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("%g");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("%g", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormapScaleFlags flags = (ImPlotColormapScaleFlags)0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ColormapScale(ReadOnlySpan<char> label, double scale_min, double scale_max, Vector2 size, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotColormapScaleFlags flags = (ImPlotColormapScaleFlags)0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#endif
+        public static void ColormapScale(string label, double scale_min, double scale_max, Vector2 size, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotColormapScaleFlags flags = (ImPlotColormapScaleFlags)0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ColormapScale(ReadOnlySpan<char> label, double scale_min, double scale_max, Vector2 size, ReadOnlySpan<char> format, ImPlotColormapScaleFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#endif
+        public static void ColormapScale(string label, double scale_min, double scale_max, Vector2 size, string format, ImPlotColormapScaleFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void ColormapScale(ReadOnlySpan<char> label, double scale_min, double scale_max, Vector2 size, ReadOnlySpan<char> format, ImPlotColormapScaleFlags flags, ImPlotColormap cmap)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#endif
+        public static void ColormapScale(string label, double scale_min, double scale_max, Vector2 size, string format, ImPlotColormapScaleFlags flags, ImPlotColormap cmap)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotNative.ImPlot_ColormapScale(native_label, scale_min, scale_max, size, native_format, flags, cmap);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            if (format_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_format);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapSlider(ReadOnlySpan<char> label, ref float t)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            Vector4* @out = null;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            fixed (float* native_t = &t)
+            {
+                byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, @out, native_format, cmap);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#endif
+        public static bool ColormapSlider(string label, ref float t)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            Vector4* @out = null;
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            fixed (float* native_t = &t)
+            {
+                byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, @out, native_format, cmap);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label);
+                }
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_format);
+                }
+                return ret != 0;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapSlider(ReadOnlySpan<char> label, ref float t, out Vector4 @out)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            fixed (float* native_t = &t)
+            {
+                fixed (Vector4* native_out = &@out)
+                {
+                    byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, native_out, native_format, cmap);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool ColormapSlider(string label, ref float t, out Vector4 @out)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+                format_byteCount = Encoding.UTF8.GetByteCount("");
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8("", native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            fixed (float* native_t = &t)
+            {
+                fixed (Vector4* native_out = &@out)
+                {
+                    byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, native_out, native_format, cmap);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapSlider(ReadOnlySpan<char> label, ref float t, out Vector4 @out, ReadOnlySpan<char> format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            fixed (float* native_t = &t)
+            {
+                fixed (Vector4* native_out = &@out)
+                {
+                    byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, native_out, native_format, cmap);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool ColormapSlider(string label, ref float t, out Vector4 @out, string format)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            fixed (float* native_t = &t)
+            {
+                fixed (Vector4* native_out = &@out)
+                {
+                    byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, native_out, native_format, cmap);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ColormapSlider(ReadOnlySpan<char> label, ref float t, out Vector4 @out, ReadOnlySpan<char> format, ImPlotColormap cmap)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (float* native_t = &t)
+            {
+                fixed (Vector4* native_out = &@out)
+                {
+                    byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, native_out, native_format, cmap);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+#endif
+        public static bool ColormapSlider(string label, ref float t, out Vector4 @out, string format, ImPlotColormap cmap)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte* native_format;
+            int format_byteCount = 0;
+            if (format != null)
+            {
+                format_byteCount = Encoding.UTF8.GetByteCount(format);
+                if (format_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_format = Util.Allocate(format_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_format_stackBytes = stackalloc byte[format_byteCount + 1];
+                    native_format = native_format_stackBytes;
+                }
+                int native_format_offset = Util.GetUtf8(format, native_format, format_byteCount);
+                native_format[native_format_offset] = 0;
+            }
+            else { native_format = null; }
+            fixed (float* native_t = &t)
+            {
+                fixed (Vector4* native_out = &@out)
+                {
+                    byte ret = ImPlotNative.ImPlot_ColormapSlider(native_label, native_t, native_out, native_format, cmap);
+                    if (label_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label);
+                    }
+                    if (format_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_format);
+                    }
+                    return ret != 0;
+                }
+            }
+        }
+        public static IntPtr CreateContext()
+        {
+            IntPtr ret = ImPlotNative.ImPlot_CreateContext();
+            return ret;
+        }
+        public static void DestroyContext()
+        {
+            IntPtr ctx = IntPtr.Zero;
+            ImPlotNative.ImPlot_DestroyContext(ctx);
+        }
+        public static void DestroyContext(IntPtr ctx)
+        {
+            ImPlotNative.ImPlot_DestroyContext(ctx);
+        }
+        public static bool DragLineX(int id, ref double x, Vector4 col)
+        {
+            float thickness = 1;
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_x = &x)
+            {
+                byte ret = ImPlotNative.ImPlot_DragLineX(id, native_x, col, thickness, flags);
+                return ret != 0;
+            }
+        }
+        public static bool DragLineX(int id, ref double x, Vector4 col, float thickness)
+        {
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_x = &x)
+            {
+                byte ret = ImPlotNative.ImPlot_DragLineX(id, native_x, col, thickness, flags);
+                return ret != 0;
+            }
+        }
+        public static bool DragLineX(int id, ref double x, Vector4 col, float thickness, ImPlotDragToolFlags flags)
+        {
+            fixed (double* native_x = &x)
+            {
+                byte ret = ImPlotNative.ImPlot_DragLineX(id, native_x, col, thickness, flags);
+                return ret != 0;
+            }
+        }
+        public static bool DragLineY(int id, ref double y, Vector4 col)
+        {
+            float thickness = 1;
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_y = &y)
+            {
+                byte ret = ImPlotNative.ImPlot_DragLineY(id, native_y, col, thickness, flags);
+                return ret != 0;
+            }
+        }
+        public static bool DragLineY(int id, ref double y, Vector4 col, float thickness)
+        {
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_y = &y)
+            {
+                byte ret = ImPlotNative.ImPlot_DragLineY(id, native_y, col, thickness, flags);
+                return ret != 0;
+            }
+        }
+        public static bool DragLineY(int id, ref double y, Vector4 col, float thickness, ImPlotDragToolFlags flags)
+        {
+            fixed (double* native_y = &y)
+            {
+                byte ret = ImPlotNative.ImPlot_DragLineY(id, native_y, col, thickness, flags);
+                return ret != 0;
+            }
+        }
+        public static bool DragPoint(int id, ref double x, ref double y, Vector4 col)
+        {
+            float size = 4;
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_x = &x)
+            {
+                fixed (double* native_y = &y)
+                {
+                    byte ret = ImPlotNative.ImPlot_DragPoint(id, native_x, native_y, col, size, flags);
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool DragPoint(int id, ref double x, ref double y, Vector4 col, float size)
+        {
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_x = &x)
+            {
+                fixed (double* native_y = &y)
+                {
+                    byte ret = ImPlotNative.ImPlot_DragPoint(id, native_x, native_y, col, size, flags);
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool DragPoint(int id, ref double x, ref double y, Vector4 col, float size, ImPlotDragToolFlags flags)
+        {
+            fixed (double* native_x = &x)
+            {
+                fixed (double* native_y = &y)
+                {
+                    byte ret = ImPlotNative.ImPlot_DragPoint(id, native_x, native_y, col, size, flags);
+                    return ret != 0;
+                }
+            }
+        }
+        public static bool DragRect(int id, ref double x1, ref double y1, ref double x2, ref double y2, Vector4 col)
+        {
+            ImPlotDragToolFlags flags = (ImPlotDragToolFlags)0;
+            fixed (double* native_x1 = &x1)
+            {
+                fixed (double* native_y1 = &y1)
+                {
+                    fixed (double* native_x2 = &x2)
+                    {
+                        fixed (double* native_y2 = &y2)
+                        {
+                            byte ret = ImPlotNative.ImPlot_DragRect(id, native_x1, native_y1, native_x2, native_y2, col, flags);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static bool DragRect(int id, ref double x1, ref double y1, ref double x2, ref double y2, Vector4 col, ImPlotDragToolFlags flags)
+        {
+            fixed (double* native_x1 = &x1)
+            {
+                fixed (double* native_y1 = &y1)
+                {
+                    fixed (double* native_x2 = &x2)
+                    {
+                        fixed (double* native_y2 = &y2)
+                        {
+                            byte ret = ImPlotNative.ImPlot_DragRect(id, native_x1, native_y1, native_x2, native_y2, col, flags);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
+        public static void EndAlignedPlots()
+        {
+            ImPlotNative.ImPlot_EndAlignedPlots();
+        }
+        public static void EndDragDropSource()
+        {
+            ImPlotNative.ImPlot_EndDragDropSource();
+        }
+        public static void EndDragDropTarget()
+        {
+            ImPlotNative.ImPlot_EndDragDropTarget();
+        }
+        public static void EndLegendPopup()
+        {
+            ImPlotNative.ImPlot_EndLegendPopup();
+        }
+        public static void EndPlot()
+        {
+            ImPlotNative.ImPlot_EndPlot();
+        }
+        public static void EndSubplots()
+        {
+            ImPlotNative.ImPlot_EndSubplots();
+        }
+        public static Vector4 GetColormapColor(int idx)
+        {
+            Vector4 __retval;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_GetColormapColor(&__retval, idx, cmap);
+            return __retval;
+        }
+        public static Vector4 GetColormapColor(int idx, ImPlotColormap cmap)
+        {
+            Vector4 __retval;
+            ImPlotNative.ImPlot_GetColormapColor(&__retval, idx, cmap);
+            return __retval;
+        }
+        public static int GetColormapCount()
+        {
+            int ret = ImPlotNative.ImPlot_GetColormapCount();
+            return ret;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static ImPlotColormap GetColormapIndex(ReadOnlySpan<char> name)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImPlotColormap ret = ImPlotNative.ImPlot_GetColormapIndex(native_name);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+            return ret;
+        }
+#endif
+        public static ImPlotColormap GetColormapIndex(string name)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImPlotColormap ret = ImPlotNative.ImPlot_GetColormapIndex(native_name);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+            return ret;
+        }
+        public static string GetColormapName(ImPlotColormap cmap)
+        {
+            byte* ret = ImPlotNative.ImPlot_GetColormapName(cmap);
+            return Util.StringFromPtr(ret);
+        }
+        public static int GetColormapSize()
+        {
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            int ret = ImPlotNative.ImPlot_GetColormapSize(cmap);
+            return ret;
+        }
+        public static int GetColormapSize(ImPlotColormap cmap)
+        {
+            int ret = ImPlotNative.ImPlot_GetColormapSize(cmap);
+            return ret;
+        }
+        public static IntPtr GetCurrentContext()
+        {
+            IntPtr ret = ImPlotNative.ImPlot_GetCurrentContext();
+            return ret;
+        }
+        public static ImPlotInputMapPtr GetInputMap()
+        {
+            ImPlotInputMap* ret = ImPlotNative.ImPlot_GetInputMap();
+            return new ImPlotInputMapPtr(ret);
+        }
+        public static Vector4 GetLastItemColor()
+        {
+            Vector4 __retval;
+            ImPlotNative.ImPlot_GetLastItemColor(&__retval);
+            return __retval;
+        }
+        public static string GetMarkerName(ImPlotMarker idx)
+        {
+            byte* ret = ImPlotNative.ImPlot_GetMarkerName(idx);
+            return Util.StringFromPtr(ret);
+        }
+        public static ImDrawListPtr GetPlotDrawList()
+        {
+            ImDrawList* ret = ImPlotNative.ImPlot_GetPlotDrawList();
+            return new ImDrawListPtr(ret);
+        }
+        public static ImPlotRect GetPlotLimits()
+        {
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotRect ret = ImPlotNative.ImPlot_GetPlotLimits(x_axis, y_axis);
+            return ret;
+        }
+        public static ImPlotRect GetPlotLimits(ImAxis x_axis)
+        {
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotRect ret = ImPlotNative.ImPlot_GetPlotLimits(x_axis, y_axis);
+            return ret;
+        }
+        public static ImPlotRect GetPlotLimits(ImAxis x_axis, ImAxis y_axis)
+        {
+            ImPlotRect ret = ImPlotNative.ImPlot_GetPlotLimits(x_axis, y_axis);
+            return ret;
+        }
+        public static ImPlotPoint GetPlotMousePos()
+        {
+            ImPlotPoint __retval;
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_GetPlotMousePos(&__retval, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint GetPlotMousePos(ImAxis x_axis)
+        {
+            ImPlotPoint __retval;
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_GetPlotMousePos(&__retval, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint GetPlotMousePos(ImAxis x_axis, ImAxis y_axis)
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlot_GetPlotMousePos(&__retval, x_axis, y_axis);
+            return __retval;
+        }
+        public static Vector2 GetPlotPos()
+        {
+            Vector2 __retval;
+            ImPlotNative.ImPlot_GetPlotPos(&__retval);
+            return __retval;
+        }
+        public static ImPlotRect GetPlotSelection()
+        {
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotRect ret = ImPlotNative.ImPlot_GetPlotSelection(x_axis, y_axis);
+            return ret;
+        }
+        public static ImPlotRect GetPlotSelection(ImAxis x_axis)
+        {
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotRect ret = ImPlotNative.ImPlot_GetPlotSelection(x_axis, y_axis);
+            return ret;
+        }
+        public static ImPlotRect GetPlotSelection(ImAxis x_axis, ImAxis y_axis)
+        {
+            ImPlotRect ret = ImPlotNative.ImPlot_GetPlotSelection(x_axis, y_axis);
+            return ret;
+        }
+        public static Vector2 GetPlotSize()
+        {
+            Vector2 __retval;
+            ImPlotNative.ImPlot_GetPlotSize(&__retval);
+            return __retval;
+        }
+        public static ImPlotStylePtr GetStyle()
+        {
+            ImPlotStyle* ret = ImPlotNative.ImPlot_GetStyle();
+            return new ImPlotStylePtr(ret);
+        }
+        public static string GetStyleColorName(ImPlotCol idx)
+        {
+            byte* ret = ImPlotNative.ImPlot_GetStyleColorName(idx);
+            return Util.StringFromPtr(ret);
+        }
+        public static void HideNextItem()
+        {
+            byte hidden = 1;
+            ImPlotCond cond = ImPlotCond.Once;
+            ImPlotNative.ImPlot_HideNextItem(hidden, cond);
+        }
+        public static void HideNextItem(bool hidden)
+        {
+            byte native_hidden = hidden ? (byte)1 : (byte)0;
+            ImPlotCond cond = ImPlotCond.Once;
+            ImPlotNative.ImPlot_HideNextItem(native_hidden, cond);
+        }
+        public static void HideNextItem(bool hidden, ImPlotCond cond)
+        {
+            byte native_hidden = hidden ? (byte)1 : (byte)0;
+            ImPlotNative.ImPlot_HideNextItem(native_hidden, cond);
+        }
+        public static bool IsAxisHovered(ImAxis axis)
+        {
+            byte ret = ImPlotNative.ImPlot_IsAxisHovered(axis);
+            return ret != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool IsLegendEntryHovered(ReadOnlySpan<char> label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte ret = ImPlotNative.ImPlot_IsLegendEntryHovered(native_label_id);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool IsLegendEntryHovered(string label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte ret = ImPlotNative.ImPlot_IsLegendEntryHovered(native_label_id);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+            return ret != 0;
+        }
+        public static bool IsPlotHovered()
+        {
+            byte ret = ImPlotNative.ImPlot_IsPlotHovered();
+            return ret != 0;
+        }
+        public static bool IsPlotSelected()
+        {
+            byte ret = ImPlotNative.ImPlot_IsPlotSelected();
+            return ret != 0;
+        }
+        public static bool IsSubplotsHovered()
+        {
+            byte ret = ImPlotNative.ImPlot_IsSubplotsHovered();
+            return ret != 0;
+        }
+        public static void ItemIcon(Vector4 col)
+        {
+            ImPlotNative.ImPlot_ItemIcon_Vec4(col);
+        }
+        public static void ItemIcon(uint col)
+        {
+            ImPlotNative.ImPlot_ItemIcon_U32(col);
+        }
+        public static void MapInputDefault()
+        {
+            ImPlotInputMap* dst = null;
+            ImPlotNative.ImPlot_MapInputDefault(dst);
+        }
+        public static void MapInputDefault(ImPlotInputMapPtr dst)
+        {
+            ImPlotInputMap* native_dst = dst.NativePtr;
+            ImPlotNative.ImPlot_MapInputDefault(native_dst);
+        }
+        public static void MapInputReverse()
+        {
+            ImPlotInputMap* dst = null;
+            ImPlotNative.ImPlot_MapInputReverse(dst);
+        }
+        public static void MapInputReverse(ImPlotInputMapPtr dst)
+        {
+            ImPlotInputMap* native_dst = dst.NativePtr;
+            ImPlotNative.ImPlot_MapInputReverse(native_dst);
+        }
+        public static Vector4 NextColormapColor()
+        {
+            Vector4 __retval;
+            ImPlotNative.ImPlot_NextColormapColor(&__retval);
+            return __retval;
+        }
+        public static ImPlotPoint PixelsToPlot(Vector2 pix)
+        {
+            ImPlotPoint __retval;
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PixelsToPlot_Vec2(&__retval, pix, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint PixelsToPlot(Vector2 pix, ImAxis x_axis)
+        {
+            ImPlotPoint __retval;
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PixelsToPlot_Vec2(&__retval, pix, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint PixelsToPlot(Vector2 pix, ImAxis x_axis, ImAxis y_axis)
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlot_PixelsToPlot_Vec2(&__retval, pix, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint PixelsToPlot(float x, float y)
+        {
+            ImPlotPoint __retval;
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PixelsToPlot_Float(&__retval, x, y, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint PixelsToPlot(float x, float y, ImAxis x_axis)
+        {
+            ImPlotPoint __retval;
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PixelsToPlot_Float(&__retval, x, y, x_axis, y_axis);
+            return __retval;
+        }
+        public static ImPlotPoint PixelsToPlot(float x, float y, ImAxis x_axis, ImAxis y_axis)
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlot_PixelsToPlot_Float(&__retval, x, y, x_axis, y_axis);
+            return __retval;
+        }
+        public static void PlotBarGroups(string[] label_ids, ref float values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_FloatPtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref float values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_FloatPtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref float values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_FloatPtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref float values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_FloatPtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref double values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_doublePtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref double values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_doublePtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref double values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_doublePtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref double values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_doublePtr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref sbyte values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref sbyte values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref sbyte values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref sbyte values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref byte values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref byte values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref byte values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref byte values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U8Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref short values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref short values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref short values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref short values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ushort values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ushort values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ushort values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ushort values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U16Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref int values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref int values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref int values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref int values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref uint values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref uint values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref uint values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref uint values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U32Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref long values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref long values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref long values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref long values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_S64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ulong values, int item_count, int group_count)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double group_size = 0.67;
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ulong values, int item_count, int group_count, double group_size)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            double shift = 0;
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ulong values, int item_count, int group_count, double group_size, double shift)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            ImPlotBarGroupsFlags flags = (ImPlotBarGroupsFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+        public static void PlotBarGroups(string[] label_ids, ref ulong values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBarGroups_U64Ptr(native_label_ids, native_values, item_count, group_count, group_size, shift, flags);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_FloatPtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_doublePtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U8PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U16PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U32PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_S64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_size = 0.67;
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong values, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double shift = 0;
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong values, int count, double bar_size, double shift)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong values, int count, double bar_size, double shift, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotBars_U64PtrInt(native_label_id, native_values, count, bar_size, shift, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref float xs, ref float ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref double xs, ref double ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref sbyte xs, ref sbyte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref byte xs, ref byte ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref short xs, ref short ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ushort xs, ref ushort ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref int xs, ref int ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref uint xs, ref uint ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref long xs, ref long ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double bar_size, ImPlotBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotBars(string label_id, ref ulong xs, ref ulong ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotBars_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, bar_size, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBarsG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            ImPlotNative.ImPlot_PlotBarsG(native_label_id, getter, native_data, count, bar_size, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotBarsG(string label_id, IntPtr getter, IntPtr data, int count, double bar_size)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotBarsFlags flags = (ImPlotBarsFlags)0;
+            ImPlotNative.ImPlot_PlotBarsG(native_label_id, getter, native_data, count, bar_size, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotBarsG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotBarsG(native_label_id, getter, native_data, count, bar_size, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotBarsG(string label_id, IntPtr getter, IntPtr data, int count, double bar_size, ImPlotBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotBarsG(native_label_id, getter, native_data, count, bar_size, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref float xs, ref float ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref float xs, ref float ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref float xs, ref float ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_FloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref double xs, ref double ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref double xs, ref double ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref double xs, ref double ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_doublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref byte xs, ref byte ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref short xs, ref short ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref short xs, ref short ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref short xs, ref short ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref int xs, ref int ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref int xs, ref int ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref int xs, ref int ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref uint xs, ref uint ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref long xs, ref long ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref long xs, ref long ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref long xs, ref long ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_S64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigital(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotDigital(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotDigital_U64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigitalG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            ImPlotNative.ImPlot_PlotDigitalG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotDigitalG(string label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotDigitalFlags flags = (ImPlotDigitalFlags)0;
+            ImPlotNative.ImPlot_PlotDigitalG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDigitalG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotDigitalG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotDigitalG(string label_id, IntPtr getter, IntPtr data, int count, ImPlotDigitalFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotDigitalG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDummy(ReadOnlySpan<char> label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDummyFlags flags = (ImPlotDummyFlags)0;
+            ImPlotNative.ImPlot_PlotDummy(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotDummy(string label_id)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotDummyFlags flags = (ImPlotDummyFlags)0;
+            ImPlotNative.ImPlot_PlotDummy(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotDummy(ReadOnlySpan<char> label_id, ImPlotDummyFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotNative.ImPlot_PlotDummy(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotDummy(string label_id, ImPlotDummyFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotNative.ImPlot_PlotDummy(native_label_id, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_err = &err)
+                    {
+                        ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(native_label_id, native_xs, native_ys, native_err, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref float xs, ref float ys, ref float neg, ref float pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    fixed (float* native_neg = &neg)
+                    {
+                        fixed (float* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref double xs, ref double ys, ref double neg, ref double pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    fixed (double* native_neg = &neg)
+                    {
+                        fixed (double* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref sbyte xs, ref sbyte ys, ref sbyte neg, ref sbyte pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    fixed (sbyte* native_neg = &neg)
+                    {
+                        fixed (sbyte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref byte xs, ref byte ys, ref byte neg, ref byte pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    fixed (byte* native_neg = &neg)
+                    {
+                        fixed (byte* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref short xs, ref short ys, ref short neg, ref short pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    fixed (short* native_neg = &neg)
+                    {
+                        fixed (short* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ushort xs, ref ushort ys, ref ushort neg, ref ushort pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    fixed (ushort* native_neg = &neg)
+                    {
+                        fixed (ushort* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref int xs, ref int ys, ref int neg, ref int pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    fixed (int* native_neg = &neg)
+                    {
+                        fixed (int* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref uint xs, ref uint ys, ref uint neg, ref uint pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    fixed (uint* native_neg = &neg)
+                    {
+                        fixed (uint* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref long xs, ref long ys, ref long neg, ref long pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    fixed (long* native_neg = &neg)
+                    {
+                        fixed (long* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotErrorBarsFlags flags = (ImPlotErrorBarsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotErrorBars(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotErrorBars(string label_id, ref ulong xs, ref ulong ys, ref ulong neg, ref ulong pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    fixed (ulong* native_neg = &neg)
+                    {
+                        fixed (ulong* native_pos = &pos)
+                        {
+                            ImPlotNative.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys, native_neg, native_pos, count, flags, offset, stride);
+                            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                            {
+                                Util.Free(native_label_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref float values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref float values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_FloatPtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref double values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref double values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_doublePtr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref sbyte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref byte values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U8Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref short values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref short values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ushort values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U16Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref int values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref int values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref uint values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U32Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref long values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref long values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_S64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_min = 0;
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale_max = 0;
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_min = new ImPlotPoint { x = 0, y = 0 };
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPoint bounds_max = new ImPlotPoint { x = 1, y = 1 };
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotHeatmapFlags flags = (ImPlotHeatmapFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotHeatmap(ReadOnlySpan<char> label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, ReadOnlySpan<char> label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotHeatmap(string label_id, ref ulong values, int rows, int cols, double scale_min, double scale_max, string label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotHeatmap_U64Ptr(native_label_id, native_values, rows, cols, scale_min, scale_max, native_label_fmt, bounds_min, bounds_max, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref float values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref float values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref float values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref float values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref float values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref float values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref float values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref float values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_FloatPtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref double values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref double values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref double values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref double values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref double values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref double values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref double values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref double values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_doublePtr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref sbyte values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref sbyte values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref sbyte values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref sbyte values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref sbyte values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref sbyte values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref sbyte values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref sbyte values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref byte values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref byte values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref byte values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref byte values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref byte values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref byte values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref byte values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref byte values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U8Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref short values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref short values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref short values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref short values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref short values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref short values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref short values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref short values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ushort values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ushort values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ushort values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ushort values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ushort values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ushort values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ushort values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ushort values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U16Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref int values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref int values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref int values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref int values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref int values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref int values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref int values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref int values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref uint values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref uint values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref uint values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref uint values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref uint values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref uint values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref uint values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref uint values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U32Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref long values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref long values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref long values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref long values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref long values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref long values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref long values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref long values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_S64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int bins = (int)ImPlotBin.Sturges;
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ulong values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ulong values, int count, int bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double bar_scale = 1.0;
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ulong values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ulong values, int count, int bins, double bar_scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRange range = new ImPlotRange();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ulong values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ulong values, int count, int bins, double bar_scale, ImPlotRange range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram(ReadOnlySpan<char> label_id, ref ulong values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#endif
+        public static double PlotHistogram(string label_id, ref ulong values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                double ret = ImPlotNative.ImPlot_PlotHistogram_U64Ptr(native_label_id, native_values, count, bins, bar_scale, range, flags);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+                return ret;
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref float xs, ref float ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref float xs, ref float ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref float xs, ref float ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref float xs, ref float ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_FloatPtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref double xs, ref double ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref double xs, ref double ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref double xs, ref double ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref double xs, ref double ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_doublePtr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref sbyte xs, ref sbyte ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref byte xs, ref byte ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref byte xs, ref byte ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref byte xs, ref byte ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref byte xs, ref byte ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U8Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref short xs, ref short ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref short xs, ref short ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref short xs, ref short ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref short xs, ref short ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ushort xs, ref ushort ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ushort xs, ref ushort ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ushort xs, ref ushort ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ushort xs, ref ushort ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U16Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref int xs, ref int ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref int xs, ref int ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref int xs, ref int ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref int xs, ref int ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref uint xs, ref uint ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref uint xs, ref uint ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref uint xs, ref uint ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref uint xs, ref uint ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U32Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref long xs, ref long ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref long xs, ref long ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref long xs, ref long ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref long xs, ref long ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_S64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int x_bins = (int)ImPlotBin.Sturges;
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ulong xs, ref ulong ys, int count, int x_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int y_bins = (int)ImPlotBin.Sturges;
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ulong xs, ref ulong ys, int count, int x_bins, int y_bins)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotRect range = new ImPlotRect();
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ulong xs, ref ulong ys, int count, int x_bins, int y_bins, ImPlotRect range)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotHistogramFlags flags = (ImPlotHistogramFlags)0;
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static double PlotHistogram2D(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#endif
+        public static double PlotHistogram2D(string label_id, ref ulong xs, ref ulong ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    double ret = ImPlotNative.ImPlot_PlotHistogram2D_U64Ptr(native_label_id, native_xs, native_ys, count, x_bins, y_bins, range, flags);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                    return ret;
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotImage(ReadOnlySpan<char> label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            Vector2 uv0 = new Vector2();
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            Vector2 uv0 = new Vector2();
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotImage(ReadOnlySpan<char> label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            Vector2 uv1 = new Vector2(1, 1);
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotImage(ReadOnlySpan<char> label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            Vector4 tint_col = new Vector4(1, 1, 1, 1);
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotImage(ReadOnlySpan<char> label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotImageFlags flags = (ImPlotImageFlags)0;
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotImage(ReadOnlySpan<char> label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col, ImPlotImageFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotImage(string label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col, ImPlotImageFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotNative.ImPlot_PlotImage(native_label_id, user_texture_id, bounds_min, bounds_max, uv0, uv1, tint_col, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref float values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref float values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref float values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref float values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref float values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref float values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_FloatPtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref double values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref double values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref double values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref double values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref double values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref double values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_doublePtr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref sbyte values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref sbyte values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref sbyte values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref sbyte values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref sbyte values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref sbyte values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref byte values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref byte values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref byte values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref byte values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref byte values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref byte values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U8Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref short values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref short values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref short values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref short values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref short values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref short values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ushort values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ushort values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ushort values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ushort values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ushort values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ushort values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U16Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref int values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref int values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref int values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref int values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref int values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref int values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref uint values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref uint values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref uint values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref uint values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref uint values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref uint values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U32Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref long values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref long values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref long values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref long values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref long values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref long values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_S64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotInfLinesFlags flags = (ImPlotInfLinesFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ulong values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ulong values, int count, ImPlotInfLinesFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ulong values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ulong values, int count, ImPlotInfLinesFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotInfLines(ReadOnlySpan<char> label_id, ref ulong values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotInfLines(string label_id, ref ulong values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotInfLines_U64Ptr(native_label_id, native_values, count, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotLine_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float xs, ref float ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float xs, ref float ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref float xs, ref float ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double xs, ref double ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double xs, ref double ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref double xs, ref double ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref byte xs, ref byte ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short xs, ref short ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short xs, ref short ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref short xs, ref short ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int xs, ref int ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int xs, ref int ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref int xs, ref int ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref uint xs, ref uint ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long xs, ref long ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long xs, ref long ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref long xs, ref long ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotLineFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLine(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotLine(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotLineFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotLine_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLineG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            ImPlotNative.ImPlot_PlotLineG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotLineG(string label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotLineFlags flags = (ImPlotLineFlags)0;
+            ImPlotNative.ImPlot_PlotLineG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotLineG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotLineG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotLineG(string label_id, IntPtr getter, IntPtr data, int count, ImPlotLineFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotLineG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref float values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_FloatPtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref double values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_doublePtr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref sbyte values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref byte values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U8Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref short values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref ushort values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U16Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref int values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref uint values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U32Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref long values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_S64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount("%.1f");
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8("%.1f", native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, string label_fmt)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            double angle0 = 90;
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, string label_fmt, double angle0)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            ImPlotPieChartFlags flags = (ImPlotPieChartFlags)0;
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, ReadOnlySpan<char> label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#endif
+        public static void PlotPieChart(string[] label_ids, ref ulong values, int count, double x, double y, double radius, string label_fmt, double angle0, ImPlotPieChartFlags flags)
+        {
+            int* label_ids_byteCounts = stackalloc int[label_ids.Length];
+            int label_ids_byteCount = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                label_ids_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                label_ids_byteCount += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_ids_data = stackalloc byte[label_ids_byteCount];
+            int offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                string s = label_ids[i];
+                offset += Util.GetUtf8(s, native_label_ids_data + offset, label_ids_byteCounts[i]);
+                native_label_ids_data[offset++] = 0;
+            }
+            byte** native_label_ids = stackalloc byte*[label_ids.Length];
+            offset = 0;
+            for (int i = 0; i < label_ids.Length; i++)
+            {
+                native_label_ids[i] = &native_label_ids_data[offset];
+                offset += label_ids_byteCounts[i] + 1;
+            }
+            byte* native_label_fmt;
+            int label_fmt_byteCount = 0;
+            if (label_fmt != null)
+            {
+                label_fmt_byteCount = Encoding.UTF8.GetByteCount(label_fmt);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_fmt = Util.Allocate(label_fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_fmt_stackBytes = stackalloc byte[label_fmt_byteCount + 1];
+                    native_label_fmt = native_label_fmt_stackBytes;
+                }
+                int native_label_fmt_offset = Util.GetUtf8(label_fmt, native_label_fmt, label_fmt_byteCount);
+                native_label_fmt[native_label_fmt_offset] = 0;
+            }
+            else { native_label_fmt = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotPieChart_U64Ptr(native_label_ids, native_values, count, x, y, radius, native_label_fmt, angle0, flags);
+                if (label_fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_fmt);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotScatter_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float xs, ref float ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float xs, ref float ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref float xs, ref float ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double xs, ref double ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double xs, ref double ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref double xs, ref double ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref byte xs, ref byte ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short xs, ref short ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short xs, ref short ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref short xs, ref short ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int xs, ref int ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int xs, ref int ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref int xs, ref int ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref uint xs, ref uint ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long xs, ref long ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long xs, ref long ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref long xs, ref long ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotScatterFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatter(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotScatter(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotScatterFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotScatter_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatterG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            ImPlotNative.ImPlot_PlotScatterG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotScatterG(string label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotScatterFlags flags = (ImPlotScatterFlags)0;
+            ImPlotNative.ImPlot_PlotScatterG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotScatterG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotScatterG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotScatterG(string label_id, IntPtr getter, IntPtr data, int count, ImPlotScatterFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotScatterG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_FloatPtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_doublePtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U8PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U16PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U32PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_S64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count, double yref, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count, double yref, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotShaded_U64PtrInt(native_label_id, native_values, count, yref, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double yref = 0;
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double yref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double yref, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double yref, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrInt(native_label_id, native_xs, native_ys, count, yref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys1, ref float ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys1, ref float ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys1, ref float ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref float xs, ref float ys1, ref float ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref float xs, ref float ys1, ref float ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys1 = &ys1)
+                {
+                    fixed (float* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys1, ref double ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys1, ref double ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys1, ref double ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref double xs, ref double ys1, ref double ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref double xs, ref double ys1, ref double ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys1 = &ys1)
+                {
+                    fixed (double* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref sbyte xs, ref sbyte ys1, ref sbyte ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys1 = &ys1)
+                {
+                    fixed (sbyte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys1, ref byte ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref byte xs, ref byte ys1, ref byte ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys1 = &ys1)
+                {
+                    fixed (byte* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys1, ref short ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys1, ref short ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys1, ref short ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref short xs, ref short ys1, ref short ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref short xs, ref short ys1, ref short ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys1 = &ys1)
+                {
+                    fixed (short* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ushort xs, ref ushort ys1, ref ushort ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys1 = &ys1)
+                {
+                    fixed (ushort* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys1, ref int ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys1, ref int ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys1, ref int ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref int xs, ref int ys1, ref int ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref int xs, ref int ys1, ref int ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys1 = &ys1)
+                {
+                    fixed (int* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys1, ref uint ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref uint xs, ref uint ys1, ref uint ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys1 = &ys1)
+                {
+                    fixed (uint* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys1, ref long ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys1, ref long ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys1, ref long ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref long xs, ref long ys1, ref long ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref long xs, ref long ys1, ref long ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys1 = &ys1)
+                {
+                    fixed (long* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, ImPlotShadedFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShaded(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotShaded(string label_id, ref ulong xs, ref ulong ys1, ref ulong ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys1 = &ys1)
+                {
+                    fixed (ulong* native_ys2 = &ys2)
+                    {
+                        ImPlotNative.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(native_label_id, native_xs, native_ys1, native_ys2, count, flags, offset, stride);
+                        if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                        {
+                            Util.Free(native_label_id);
+                        }
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShadedG(ReadOnlySpan<char> label_id, IntPtr getter1, IntPtr data1, IntPtr getter2, IntPtr data2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data1 = (void*)data1.ToPointer();
+            void* native_data2 = (void*)data2.ToPointer();
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            ImPlotNative.ImPlot_PlotShadedG(native_label_id, getter1, native_data1, getter2, native_data2, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotShadedG(string label_id, IntPtr getter1, IntPtr data1, IntPtr getter2, IntPtr data2, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data1 = (void*)data1.ToPointer();
+            void* native_data2 = (void*)data2.ToPointer();
+            ImPlotShadedFlags flags = (ImPlotShadedFlags)0;
+            ImPlotNative.ImPlot_PlotShadedG(native_label_id, getter1, native_data1, getter2, native_data2, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotShadedG(ReadOnlySpan<char> label_id, IntPtr getter1, IntPtr data1, IntPtr getter2, IntPtr data2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data1 = (void*)data1.ToPointer();
+            void* native_data2 = (void*)data2.ToPointer();
+            ImPlotNative.ImPlot_PlotShadedG(native_label_id, getter1, native_data1, getter2, native_data2, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotShadedG(string label_id, IntPtr getter1, IntPtr data1, IntPtr getter2, IntPtr data2, int count, ImPlotShadedFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data1 = (void*)data1.ToPointer();
+            void* native_data2 = (void*)data2.ToPointer();
+            ImPlotNative.ImPlot_PlotShadedG(native_label_id, getter1, native_data1, getter2, native_data2, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_FloatPtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_doublePtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U8PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U16PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U32PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_S64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xscale = 1;
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong values, int count, double xscale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double xstart = 0;
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double xstart)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStairs_U64PtrInt(native_label_id, native_values, count, xscale, xstart, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float xs, ref float ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float xs, ref float ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref float xs, ref float ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double xs, ref double ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double xs, ref double ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref double xs, ref double ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref sbyte xs, ref sbyte ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref byte xs, ref byte ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short xs, ref short ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short xs, ref short ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref short xs, ref short ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ushort xs, ref ushort ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int xs, ref int ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int xs, ref int ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref int xs, ref int ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref uint xs, ref uint ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long xs, ref long ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long xs, ref long ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref long xs, ref long ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotStairsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairs(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStairs(string label_id, ref ulong xs, ref ulong ys, int count, ImPlotStairsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStairs_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairsG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            ImPlotNative.ImPlot_PlotStairsG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotStairsG(string label_id, IntPtr getter, IntPtr data, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotStairsFlags flags = (ImPlotStairsFlags)0;
+            ImPlotNative.ImPlot_PlotStairsG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStairsG(ReadOnlySpan<char> label_id, IntPtr getter, IntPtr data, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotStairsG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#endif
+        public static void PlotStairsG(string label_id, IntPtr getter, IntPtr data, int count, ImPlotStairsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_PlotStairsG(native_label_id, getter, native_data, count, flags);
+            if (label_id_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label_id);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_FloatPtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_doublePtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U8PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U16PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U32PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_S64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double scale = 1;
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count, double @ref, double scale)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double start = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count, double @ref, double scale, double start)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_values = &values)
+            {
+                ImPlotNative.ImPlot_PlotStems_U64PtrInt(native_label_id, native_values, count, @ref, scale, start, flags, offset, stride);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    Util.Free(native_label_id);
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float xs, ref float ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(float);
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref float xs, ref float ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref float xs, ref float ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (float* native_xs = &xs)
+            {
+                fixed (float* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_FloatPtrFloatPtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double xs, ref double ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(double);
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref double xs, ref double ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref double xs, ref double ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (double* native_xs = &xs)
+            {
+                fixed (double* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_doublePtrdoublePtr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(sbyte);
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref sbyte xs, ref sbyte ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref sbyte xs, ref sbyte ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (sbyte* native_xs = &xs)
+            {
+                fixed (sbyte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S8PtrS8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(byte);
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref byte xs, ref byte ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref byte xs, ref byte ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (byte* native_xs = &xs)
+            {
+                fixed (byte* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U8PtrU8Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short xs, ref short ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(short);
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref short xs, ref short ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref short xs, ref short ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (short* native_xs = &xs)
+            {
+                fixed (short* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S16PtrS16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ushort);
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ushort xs, ref ushort ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ushort xs, ref ushort ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ushort* native_xs = &xs)
+            {
+                fixed (ushort* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U16PtrU16Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int xs, ref int ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(int);
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref int xs, ref int ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref int xs, ref int ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (int* native_xs = &xs)
+            {
+                fixed (int* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S32PtrS32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(uint);
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref uint xs, ref uint ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref uint xs, ref uint ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (uint* native_xs = &xs)
+            {
+                fixed (uint* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U32PtrU32Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long xs, ref long ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(long);
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref long xs, ref long ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref long xs, ref long ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (long* native_xs = &xs)
+            {
+                fixed (long* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_S64PtrS64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            double @ref = 0;
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double @ref)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            ImPlotStemsFlags flags = (ImPlotStemsFlags)0;
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double @ref, ImPlotStemsFlags flags)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int offset = 0;
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double @ref, ImPlotStemsFlags flags, int offset)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            int stride = sizeof(ulong);
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotStems(ReadOnlySpan<char> label_id, ref ulong xs, ref ulong ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#endif
+        public static void PlotStems(string label_id, ref ulong xs, ref ulong ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride)
+        {
+            byte* native_label_id;
+            int label_id_byteCount = 0;
+            if (label_id != null)
+            {
+                label_id_byteCount = Encoding.UTF8.GetByteCount(label_id);
+                if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label_id = Util.Allocate(label_id_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_id_stackBytes = stackalloc byte[label_id_byteCount + 1];
+                    native_label_id = native_label_id_stackBytes;
+                }
+                int native_label_id_offset = Util.GetUtf8(label_id, native_label_id, label_id_byteCount);
+                native_label_id[native_label_id_offset] = 0;
+            }
+            else { native_label_id = null; }
+            fixed (ulong* native_xs = &xs)
+            {
+                fixed (ulong* native_ys = &ys)
+                {
+                    ImPlotNative.ImPlot_PlotStems_U64PtrU64Ptr(native_label_id, native_xs, native_ys, count, @ref, flags, offset, stride);
+                    if (label_id_byteCount > Util.StackAllocationSizeLimit)
+                    {
+                        Util.Free(native_label_id);
+                    }
+                }
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotText(ReadOnlySpan<char> text, double x, double y)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            Vector2 pix_offset = new Vector2();
+            ImPlotTextFlags flags = (ImPlotTextFlags)0;
+            ImPlotNative.ImPlot_PlotText(native_text, x, y, pix_offset, flags);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#endif
+        public static void PlotText(string text, double x, double y)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            Vector2 pix_offset = new Vector2();
+            ImPlotTextFlags flags = (ImPlotTextFlags)0;
+            ImPlotNative.ImPlot_PlotText(native_text, x, y, pix_offset, flags);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotText(ReadOnlySpan<char> text, double x, double y, Vector2 pix_offset)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImPlotTextFlags flags = (ImPlotTextFlags)0;
+            ImPlotNative.ImPlot_PlotText(native_text, x, y, pix_offset, flags);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#endif
+        public static void PlotText(string text, double x, double y, Vector2 pix_offset)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImPlotTextFlags flags = (ImPlotTextFlags)0;
+            ImPlotNative.ImPlot_PlotText(native_text, x, y, pix_offset, flags);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PlotText(ReadOnlySpan<char> text, double x, double y, Vector2 pix_offset, ImPlotTextFlags flags)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImPlotNative.ImPlot_PlotText(native_text, x, y, pix_offset, flags);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+#endif
+        public static void PlotText(string text, double x, double y, Vector2 pix_offset, ImPlotTextFlags flags)
+        {
+            byte* native_text;
+            int text_byteCount = 0;
+            if (text != null)
+            {
+                text_byteCount = Encoding.UTF8.GetByteCount(text);
+                if (text_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_text = Util.Allocate(text_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_text_stackBytes = stackalloc byte[text_byteCount + 1];
+                    native_text = native_text_stackBytes;
+                }
+                int native_text_offset = Util.GetUtf8(text, native_text, text_byteCount);
+                native_text[native_text_offset] = 0;
+            }
+            else { native_text = null; }
+            ImPlotNative.ImPlot_PlotText(native_text, x, y, pix_offset, flags);
+            if (text_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_text);
+            }
+        }
+        public static Vector2 PlotToPixels(ImPlotPoint plt)
+        {
+            Vector2 __retval;
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PlotToPixels_PlotPoInt(&__retval, plt, x_axis, y_axis);
+            return __retval;
+        }
+        public static Vector2 PlotToPixels(ImPlotPoint plt, ImAxis x_axis)
+        {
+            Vector2 __retval;
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PlotToPixels_PlotPoInt(&__retval, plt, x_axis, y_axis);
+            return __retval;
+        }
+        public static Vector2 PlotToPixels(ImPlotPoint plt, ImAxis x_axis, ImAxis y_axis)
+        {
+            Vector2 __retval;
+            ImPlotNative.ImPlot_PlotToPixels_PlotPoInt(&__retval, plt, x_axis, y_axis);
+            return __retval;
+        }
+        public static Vector2 PlotToPixels(double x, double y)
+        {
+            Vector2 __retval;
+            ImAxis x_axis = (ImAxis)(-1);
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PlotToPixels_double(&__retval, x, y, x_axis, y_axis);
+            return __retval;
+        }
+        public static Vector2 PlotToPixels(double x, double y, ImAxis x_axis)
+        {
+            Vector2 __retval;
+            ImAxis y_axis = (ImAxis)(-1);
+            ImPlotNative.ImPlot_PlotToPixels_double(&__retval, x, y, x_axis, y_axis);
+            return __retval;
+        }
+        public static Vector2 PlotToPixels(double x, double y, ImAxis x_axis, ImAxis y_axis)
+        {
+            Vector2 __retval;
+            ImPlotNative.ImPlot_PlotToPixels_double(&__retval, x, y, x_axis, y_axis);
+            return __retval;
+        }
+        public static void PopColormap()
+        {
+            int count = 1;
+            ImPlotNative.ImPlot_PopColormap(count);
+        }
+        public static void PopColormap(int count)
+        {
+            ImPlotNative.ImPlot_PopColormap(count);
+        }
+        public static void PopPlotClipRect()
+        {
+            ImPlotNative.ImPlot_PopPlotClipRect();
+        }
+        public static void PopStyleColor()
+        {
+            int count = 1;
+            ImPlotNative.ImPlot_PopStyleColor(count);
+        }
+        public static void PopStyleColor(int count)
+        {
+            ImPlotNative.ImPlot_PopStyleColor(count);
+        }
+        public static void PopStyleVar()
+        {
+            int count = 1;
+            ImPlotNative.ImPlot_PopStyleVar(count);
+        }
+        public static void PopStyleVar(int count)
+        {
+            ImPlotNative.ImPlot_PopStyleVar(count);
+        }
+        public static void PushColormap(ImPlotColormap cmap)
+        {
+            ImPlotNative.ImPlot_PushColormap_PlotColormap(cmap);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void PushColormap(ReadOnlySpan<char> name)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImPlotNative.ImPlot_PushColormap_Str(native_name);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+        }
+#endif
+        public static void PushColormap(string name)
+        {
+            byte* native_name;
+            int name_byteCount = 0;
+            if (name != null)
+            {
+                name_byteCount = Encoding.UTF8.GetByteCount(name);
+                if (name_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_name = Util.Allocate(name_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_name_stackBytes = stackalloc byte[name_byteCount + 1];
+                    native_name = native_name_stackBytes;
+                }
+                int native_name_offset = Util.GetUtf8(name, native_name, name_byteCount);
+                native_name[native_name_offset] = 0;
+            }
+            else { native_name = null; }
+            ImPlotNative.ImPlot_PushColormap_Str(native_name);
+            if (name_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_name);
+            }
+        }
+        public static void PushPlotClipRect()
+        {
+            float expand = 0;
+            ImPlotNative.ImPlot_PushPlotClipRect(expand);
+        }
+        public static void PushPlotClipRect(float expand)
+        {
+            ImPlotNative.ImPlot_PushPlotClipRect(expand);
+        }
+        public static void PushStyleColor(ImPlotCol idx, uint col)
+        {
+            ImPlotNative.ImPlot_PushStyleColor_U32(idx, col);
+        }
+        public static void PushStyleColor(ImPlotCol idx, Vector4 col)
+        {
+            ImPlotNative.ImPlot_PushStyleColor_Vec4(idx, col);
+        }
+        public static void PushStyleVar(ImPlotStyleVar idx, float val)
+        {
+            ImPlotNative.ImPlot_PushStyleVar_Float(idx, val);
+        }
+        public static void PushStyleVar(ImPlotStyleVar idx, int val)
+        {
+            ImPlotNative.ImPlot_PushStyleVar_Int(idx, val);
+        }
+        public static void PushStyleVar(ImPlotStyleVar idx, Vector2 val)
+        {
+            ImPlotNative.ImPlot_PushStyleVar_Vec2(idx, val);
+        }
+        public static Vector4 SampleColormap(float t)
+        {
+            Vector4 __retval;
+            ImPlotColormap cmap = (ImPlotColormap)(-1);
+            ImPlotNative.ImPlot_SampleColormap(&__retval, t, cmap);
+            return __retval;
+        }
+        public static Vector4 SampleColormap(float t, ImPlotColormap cmap)
+        {
+            Vector4 __retval;
+            ImPlotNative.ImPlot_SampleColormap(&__retval, t, cmap);
+            return __retval;
+        }
+        public static void SetAxes(ImAxis x_axis, ImAxis y_axis)
+        {
+            ImPlotNative.ImPlot_SetAxes(x_axis, y_axis);
+        }
+        public static void SetAxis(ImAxis axis)
+        {
+            ImPlotNative.ImPlot_SetAxis(axis);
+        }
+        public static void SetCurrentContext(IntPtr ctx)
+        {
+            ImPlotNative.ImPlot_SetCurrentContext(ctx);
+        }
+        public static void SetImGuiContext(IntPtr ctx)
+        {
+            ImPlotNative.ImPlot_SetImGuiContext(ctx);
+        }
+        public static void SetNextAxesLimits(double x_min, double x_max, double y_min, double y_max)
+        {
+            ImPlotCond cond = ImPlotCond.Once;
+            ImPlotNative.ImPlot_SetNextAxesLimits(x_min, x_max, y_min, y_max, cond);
+        }
+        public static void SetNextAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond)
+        {
+            ImPlotNative.ImPlot_SetNextAxesLimits(x_min, x_max, y_min, y_max, cond);
+        }
+        public static void SetNextAxesToFit()
+        {
+            ImPlotNative.ImPlot_SetNextAxesToFit();
+        }
+        public static void SetNextAxisLimits(ImAxis axis, double v_min, double v_max)
+        {
+            ImPlotCond cond = ImPlotCond.Once;
+            ImPlotNative.ImPlot_SetNextAxisLimits(axis, v_min, v_max, cond);
+        }
+        public static void SetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond)
+        {
+            ImPlotNative.ImPlot_SetNextAxisLimits(axis, v_min, v_max, cond);
+        }
+        public static void SetNextAxisLinks(ImAxis axis, ref double link_min, ref double link_max)
+        {
+            fixed (double* native_link_min = &link_min)
+            {
+                fixed (double* native_link_max = &link_max)
+                {
+                    ImPlotNative.ImPlot_SetNextAxisLinks(axis, native_link_min, native_link_max);
+                }
+            }
+        }
+        public static void SetNextAxisToFit(ImAxis axis)
+        {
+            ImPlotNative.ImPlot_SetNextAxisToFit(axis);
+        }
+        public static void SetNextErrorBarStyle()
+        {
+            Vector4 col = new Vector4(0, 0, 0, -1);
+            float size = -1;
+            float weight = -1;
+            ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight);
+        }
+        public static void SetNextErrorBarStyle(Vector4 col)
+        {
+            float size = -1;
+            float weight = -1;
+            ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight);
+        }
+        public static void SetNextErrorBarStyle(Vector4 col, float size)
+        {
+            float weight = -1;
+            ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight);
+        }
+        public static void SetNextErrorBarStyle(Vector4 col, float size, float weight)
+        {
+            ImPlotNative.ImPlot_SetNextErrorBarStyle(col, size, weight);
+        }
+        public static void SetNextFillStyle()
+        {
+            Vector4 col = new Vector4(0, 0, 0, -1);
+            float alpha_mod = -1;
+            ImPlotNative.ImPlot_SetNextFillStyle(col, alpha_mod);
+        }
+        public static void SetNextFillStyle(Vector4 col)
+        {
+            float alpha_mod = -1;
+            ImPlotNative.ImPlot_SetNextFillStyle(col, alpha_mod);
+        }
+        public static void SetNextFillStyle(Vector4 col, float alpha_mod)
+        {
+            ImPlotNative.ImPlot_SetNextFillStyle(col, alpha_mod);
+        }
+        public static void SetNextLineStyle()
+        {
+            Vector4 col = new Vector4(0, 0, 0, -1);
+            float weight = -1;
+            ImPlotNative.ImPlot_SetNextLineStyle(col, weight);
+        }
+        public static void SetNextLineStyle(Vector4 col)
+        {
+            float weight = -1;
+            ImPlotNative.ImPlot_SetNextLineStyle(col, weight);
+        }
+        public static void SetNextLineStyle(Vector4 col, float weight)
+        {
+            ImPlotNative.ImPlot_SetNextLineStyle(col, weight);
+        }
+        public static void SetNextMarkerStyle()
+        {
+            ImPlotMarker marker = (ImPlotMarker)(-1);
+            float size = -1;
+            Vector4 fill = new Vector4(0, 0, 0, -1);
+            float weight = -1;
+            Vector4 outline = new Vector4(0, 0, 0, -1);
+            ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline);
+        }
+        public static void SetNextMarkerStyle(ImPlotMarker marker)
+        {
+            float size = -1;
+            Vector4 fill = new Vector4(0, 0, 0, -1);
+            float weight = -1;
+            Vector4 outline = new Vector4(0, 0, 0, -1);
+            ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline);
+        }
+        public static void SetNextMarkerStyle(ImPlotMarker marker, float size)
+        {
+            Vector4 fill = new Vector4(0, 0, 0, -1);
+            float weight = -1;
+            Vector4 outline = new Vector4(0, 0, 0, -1);
+            ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline);
+        }
+        public static void SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill)
+        {
+            float weight = -1;
+            Vector4 outline = new Vector4(0, 0, 0, -1);
+            ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline);
+        }
+        public static void SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill, float weight)
+        {
+            Vector4 outline = new Vector4(0, 0, 0, -1);
+            ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline);
+        }
+        public static void SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill, float weight, Vector4 outline)
+        {
+            ImPlotNative.ImPlot_SetNextMarkerStyle(marker, size, fill, weight, outline);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetupAxes(ReadOnlySpan<char> x_label, ReadOnlySpan<char> y_label)
+        {
+            byte* native_x_label;
+            int x_label_byteCount = 0;
+            if (x_label != null)
+            {
+                x_label_byteCount = Encoding.UTF8.GetByteCount(x_label);
+                if (x_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_x_label = Util.Allocate(x_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1];
+                    native_x_label = native_x_label_stackBytes;
+                }
+                int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount);
+                native_x_label[native_x_label_offset] = 0;
+            }
+            else { native_x_label = null; }
+            byte* native_y_label;
+            int y_label_byteCount = 0;
+            if (y_label != null)
+            {
+                y_label_byteCount = Encoding.UTF8.GetByteCount(y_label);
+                if (y_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_y_label = Util.Allocate(y_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1];
+                    native_y_label = native_y_label_stackBytes;
+                }
+                int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount);
+                native_y_label[native_y_label_offset] = 0;
+            }
+            else { native_y_label = null; }
+            ImPlotAxisFlags x_flags = (ImPlotAxisFlags)0;
+            ImPlotAxisFlags y_flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxes(native_x_label, native_y_label, x_flags, y_flags);
+            if (x_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_x_label);
+            }
+            if (y_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_y_label);
+            }
+        }
+#endif
+        public static void SetupAxes(string x_label, string y_label)
+        {
+            byte* native_x_label;
+            int x_label_byteCount = 0;
+            if (x_label != null)
+            {
+                x_label_byteCount = Encoding.UTF8.GetByteCount(x_label);
+                if (x_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_x_label = Util.Allocate(x_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1];
+                    native_x_label = native_x_label_stackBytes;
+                }
+                int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount);
+                native_x_label[native_x_label_offset] = 0;
+            }
+            else { native_x_label = null; }
+            byte* native_y_label;
+            int y_label_byteCount = 0;
+            if (y_label != null)
+            {
+                y_label_byteCount = Encoding.UTF8.GetByteCount(y_label);
+                if (y_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_y_label = Util.Allocate(y_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1];
+                    native_y_label = native_y_label_stackBytes;
+                }
+                int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount);
+                native_y_label[native_y_label_offset] = 0;
+            }
+            else { native_y_label = null; }
+            ImPlotAxisFlags x_flags = (ImPlotAxisFlags)0;
+            ImPlotAxisFlags y_flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxes(native_x_label, native_y_label, x_flags, y_flags);
+            if (x_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_x_label);
+            }
+            if (y_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_y_label);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetupAxes(ReadOnlySpan<char> x_label, ReadOnlySpan<char> y_label, ImPlotAxisFlags x_flags)
+        {
+            byte* native_x_label;
+            int x_label_byteCount = 0;
+            if (x_label != null)
+            {
+                x_label_byteCount = Encoding.UTF8.GetByteCount(x_label);
+                if (x_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_x_label = Util.Allocate(x_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1];
+                    native_x_label = native_x_label_stackBytes;
+                }
+                int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount);
+                native_x_label[native_x_label_offset] = 0;
+            }
+            else { native_x_label = null; }
+            byte* native_y_label;
+            int y_label_byteCount = 0;
+            if (y_label != null)
+            {
+                y_label_byteCount = Encoding.UTF8.GetByteCount(y_label);
+                if (y_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_y_label = Util.Allocate(y_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1];
+                    native_y_label = native_y_label_stackBytes;
+                }
+                int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount);
+                native_y_label[native_y_label_offset] = 0;
+            }
+            else { native_y_label = null; }
+            ImPlotAxisFlags y_flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxes(native_x_label, native_y_label, x_flags, y_flags);
+            if (x_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_x_label);
+            }
+            if (y_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_y_label);
+            }
+        }
+#endif
+        public static void SetupAxes(string x_label, string y_label, ImPlotAxisFlags x_flags)
+        {
+            byte* native_x_label;
+            int x_label_byteCount = 0;
+            if (x_label != null)
+            {
+                x_label_byteCount = Encoding.UTF8.GetByteCount(x_label);
+                if (x_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_x_label = Util.Allocate(x_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1];
+                    native_x_label = native_x_label_stackBytes;
+                }
+                int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount);
+                native_x_label[native_x_label_offset] = 0;
+            }
+            else { native_x_label = null; }
+            byte* native_y_label;
+            int y_label_byteCount = 0;
+            if (y_label != null)
+            {
+                y_label_byteCount = Encoding.UTF8.GetByteCount(y_label);
+                if (y_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_y_label = Util.Allocate(y_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1];
+                    native_y_label = native_y_label_stackBytes;
+                }
+                int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount);
+                native_y_label[native_y_label_offset] = 0;
+            }
+            else { native_y_label = null; }
+            ImPlotAxisFlags y_flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxes(native_x_label, native_y_label, x_flags, y_flags);
+            if (x_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_x_label);
+            }
+            if (y_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_y_label);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetupAxes(ReadOnlySpan<char> x_label, ReadOnlySpan<char> y_label, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags)
+        {
+            byte* native_x_label;
+            int x_label_byteCount = 0;
+            if (x_label != null)
+            {
+                x_label_byteCount = Encoding.UTF8.GetByteCount(x_label);
+                if (x_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_x_label = Util.Allocate(x_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1];
+                    native_x_label = native_x_label_stackBytes;
+                }
+                int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount);
+                native_x_label[native_x_label_offset] = 0;
+            }
+            else { native_x_label = null; }
+            byte* native_y_label;
+            int y_label_byteCount = 0;
+            if (y_label != null)
+            {
+                y_label_byteCount = Encoding.UTF8.GetByteCount(y_label);
+                if (y_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_y_label = Util.Allocate(y_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1];
+                    native_y_label = native_y_label_stackBytes;
+                }
+                int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount);
+                native_y_label[native_y_label_offset] = 0;
+            }
+            else { native_y_label = null; }
+            ImPlotNative.ImPlot_SetupAxes(native_x_label, native_y_label, x_flags, y_flags);
+            if (x_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_x_label);
+            }
+            if (y_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_y_label);
+            }
+        }
+#endif
+        public static void SetupAxes(string x_label, string y_label, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags)
+        {
+            byte* native_x_label;
+            int x_label_byteCount = 0;
+            if (x_label != null)
+            {
+                x_label_byteCount = Encoding.UTF8.GetByteCount(x_label);
+                if (x_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_x_label = Util.Allocate(x_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_x_label_stackBytes = stackalloc byte[x_label_byteCount + 1];
+                    native_x_label = native_x_label_stackBytes;
+                }
+                int native_x_label_offset = Util.GetUtf8(x_label, native_x_label, x_label_byteCount);
+                native_x_label[native_x_label_offset] = 0;
+            }
+            else { native_x_label = null; }
+            byte* native_y_label;
+            int y_label_byteCount = 0;
+            if (y_label != null)
+            {
+                y_label_byteCount = Encoding.UTF8.GetByteCount(y_label);
+                if (y_label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_y_label = Util.Allocate(y_label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_y_label_stackBytes = stackalloc byte[y_label_byteCount + 1];
+                    native_y_label = native_y_label_stackBytes;
+                }
+                int native_y_label_offset = Util.GetUtf8(y_label, native_y_label, y_label_byteCount);
+                native_y_label[native_y_label_offset] = 0;
+            }
+            else { native_y_label = null; }
+            ImPlotNative.ImPlot_SetupAxes(native_x_label, native_y_label, x_flags, y_flags);
+            if (x_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_x_label);
+            }
+            if (y_label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_y_label);
+            }
+        }
+        public static void SetupAxesLimits(double x_min, double x_max, double y_min, double y_max)
+        {
+            ImPlotCond cond = ImPlotCond.Once;
+            ImPlotNative.ImPlot_SetupAxesLimits(x_min, x_max, y_min, y_max, cond);
+        }
+        public static void SetupAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond)
+        {
+            ImPlotNative.ImPlot_SetupAxesLimits(x_min, x_max, y_min, y_max, cond);
+        }
+        public static void SetupAxis(ImAxis axis)
+        {
+            byte* native_label = null;
+            ImPlotAxisFlags flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxis(axis, native_label, flags);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetupAxis(ImAxis axis, ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImPlotAxisFlags flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxis(axis, native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+        }
+#endif
+        public static void SetupAxis(ImAxis axis, string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImPlotAxisFlags flags = (ImPlotAxisFlags)0;
+            ImPlotNative.ImPlot_SetupAxis(axis, native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetupAxis(ImAxis axis, ReadOnlySpan<char> label, ImPlotAxisFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImPlotNative.ImPlot_SetupAxis(axis, native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+        }
+#endif
+        public static void SetupAxis(ImAxis axis, string label, ImPlotAxisFlags flags)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            ImPlotNative.ImPlot_SetupAxis(axis, native_label, flags);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void SetupAxisFormat(ImAxis axis, ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_SetupAxisFormat_Str(axis, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void SetupAxisFormat(ImAxis axis, string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_SetupAxisFormat_Str(axis, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+        public static void SetupAxisFormat(ImAxis axis, IntPtr formatter)
+        {
+            void* data = null;
+            ImPlotNative.ImPlot_SetupAxisFormat_PlotFormatter(axis, formatter, data);
+        }
+        public static void SetupAxisFormat(ImAxis axis, IntPtr formatter, IntPtr data)
+        {
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_SetupAxisFormat_PlotFormatter(axis, formatter, native_data);
+        }
+        public static void SetupAxisLimits(ImAxis axis, double v_min, double v_max)
+        {
+            ImPlotCond cond = ImPlotCond.Once;
+            ImPlotNative.ImPlot_SetupAxisLimits(axis, v_min, v_max, cond);
+        }
+        public static void SetupAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond)
+        {
+            ImPlotNative.ImPlot_SetupAxisLimits(axis, v_min, v_max, cond);
+        }
+        public static void SetupAxisLimitsConstraints(ImAxis axis, double v_min, double v_max)
+        {
+            ImPlotNative.ImPlot_SetupAxisLimitsConstraints(axis, v_min, v_max);
+        }
+        public static void SetupAxisLinks(ImAxis axis, ref double link_min, ref double link_max)
+        {
+            fixed (double* native_link_min = &link_min)
+            {
+                fixed (double* native_link_max = &link_max)
+                {
+                    ImPlotNative.ImPlot_SetupAxisLinks(axis, native_link_min, native_link_max);
+                }
+            }
+        }
+        public static void SetupAxisScale(ImAxis axis, ImPlotScale scale)
+        {
+            ImPlotNative.ImPlot_SetupAxisScale_PlotScale(axis, scale);
+        }
+        public static void SetupAxisScale(ImAxis axis, IntPtr forward, IntPtr inverse)
+        {
+            void* data = null;
+            ImPlotNative.ImPlot_SetupAxisScale_PlotTransform(axis, forward, inverse, data);
+        }
+        public static void SetupAxisScale(ImAxis axis, IntPtr forward, IntPtr inverse, IntPtr data)
+        {
+            void* native_data = (void*)data.ToPointer();
+            ImPlotNative.ImPlot_SetupAxisScale_PlotTransform(axis, forward, inverse, native_data);
+        }
+        public static void SetupAxisTicks(ImAxis axis, ref double values, int n_ticks)
+        {
+            byte** labels = null;
+            byte keep_default = 0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_SetupAxisTicks_doublePtr(axis, native_values, n_ticks, labels, keep_default);
+            }
+        }
+        public static void SetupAxisTicks(ImAxis axis, ref double values, int n_ticks, string[] labels)
+        {
+            int* labels_byteCounts = stackalloc int[labels.Length];
+            int labels_byteCount = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                labels_byteCount += labels_byteCounts[i] + 1;
+            }
+            byte* native_labels_data = stackalloc byte[labels_byteCount];
+            int offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                offset += Util.GetUtf8(s, native_labels_data + offset, labels_byteCounts[i]);
+                native_labels_data[offset++] = 0;
+            }
+            byte** native_labels = stackalloc byte*[labels.Length];
+            offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                native_labels[i] = &native_labels_data[offset];
+                offset += labels_byteCounts[i] + 1;
+            }
+            byte keep_default = 0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_SetupAxisTicks_doublePtr(axis, native_values, n_ticks, native_labels, keep_default);
+            }
+        }
+        public static void SetupAxisTicks(ImAxis axis, ref double values, int n_ticks, string[] labels, bool keep_default)
+        {
+            int* labels_byteCounts = stackalloc int[labels.Length];
+            int labels_byteCount = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                labels_byteCount += labels_byteCounts[i] + 1;
+            }
+            byte* native_labels_data = stackalloc byte[labels_byteCount];
+            int offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                offset += Util.GetUtf8(s, native_labels_data + offset, labels_byteCounts[i]);
+                native_labels_data[offset++] = 0;
+            }
+            byte** native_labels = stackalloc byte*[labels.Length];
+            offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                native_labels[i] = &native_labels_data[offset];
+                offset += labels_byteCounts[i] + 1;
+            }
+            byte native_keep_default = keep_default ? (byte)1 : (byte)0;
+            fixed (double* native_values = &values)
+            {
+                ImPlotNative.ImPlot_SetupAxisTicks_doublePtr(axis, native_values, n_ticks, native_labels, native_keep_default);
+            }
+        }
+        public static void SetupAxisTicks(ImAxis axis, double v_min, double v_max, int n_ticks)
+        {
+            byte** labels = null;
+            byte keep_default = 0;
+            ImPlotNative.ImPlot_SetupAxisTicks_double(axis, v_min, v_max, n_ticks, labels, keep_default);
+        }
+        public static void SetupAxisTicks(ImAxis axis, double v_min, double v_max, int n_ticks, string[] labels)
+        {
+            int* labels_byteCounts = stackalloc int[labels.Length];
+            int labels_byteCount = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                labels_byteCount += labels_byteCounts[i] + 1;
+            }
+            byte* native_labels_data = stackalloc byte[labels_byteCount];
+            int offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                offset += Util.GetUtf8(s, native_labels_data + offset, labels_byteCounts[i]);
+                native_labels_data[offset++] = 0;
+            }
+            byte** native_labels = stackalloc byte*[labels.Length];
+            offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                native_labels[i] = &native_labels_data[offset];
+                offset += labels_byteCounts[i] + 1;
+            }
+            byte keep_default = 0;
+            ImPlotNative.ImPlot_SetupAxisTicks_double(axis, v_min, v_max, n_ticks, native_labels, keep_default);
+        }
+        public static void SetupAxisTicks(ImAxis axis, double v_min, double v_max, int n_ticks, string[] labels, bool keep_default)
+        {
+            int* labels_byteCounts = stackalloc int[labels.Length];
+            int labels_byteCount = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                labels_byteCounts[i] = Encoding.UTF8.GetByteCount(s);
+                labels_byteCount += labels_byteCounts[i] + 1;
+            }
+            byte* native_labels_data = stackalloc byte[labels_byteCount];
+            int offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                string s = labels[i];
+                offset += Util.GetUtf8(s, native_labels_data + offset, labels_byteCounts[i]);
+                native_labels_data[offset++] = 0;
+            }
+            byte** native_labels = stackalloc byte*[labels.Length];
+            offset = 0;
+            for (int i = 0; i < labels.Length; i++)
+            {
+                native_labels[i] = &native_labels_data[offset];
+                offset += labels_byteCounts[i] + 1;
+            }
+            byte native_keep_default = keep_default ? (byte)1 : (byte)0;
+            ImPlotNative.ImPlot_SetupAxisTicks_double(axis, v_min, v_max, n_ticks, native_labels, native_keep_default);
+        }
+        public static void SetupAxisZoomConstraints(ImAxis axis, double z_min, double z_max)
+        {
+            ImPlotNative.ImPlot_SetupAxisZoomConstraints(axis, z_min, z_max);
+        }
+        public static void SetupFinish()
+        {
+            ImPlotNative.ImPlot_SetupFinish();
+        }
+        public static void SetupLegend(ImPlotLocation location)
+        {
+            ImPlotLegendFlags flags = (ImPlotLegendFlags)0;
+            ImPlotNative.ImPlot_SetupLegend(location, flags);
+        }
+        public static void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags)
+        {
+            ImPlotNative.ImPlot_SetupLegend(location, flags);
+        }
+        public static void SetupMouseText(ImPlotLocation location)
+        {
+            ImPlotMouseTextFlags flags = (ImPlotMouseTextFlags)0;
+            ImPlotNative.ImPlot_SetupMouseText(location, flags);
+        }
+        public static void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags)
+        {
+            ImPlotNative.ImPlot_SetupMouseText(location, flags);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ShowColormapSelector(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ShowColormapSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ShowColormapSelector(string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ShowColormapSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+        public static void ShowDemoWindow()
+        {
+            byte* p_open = null;
+            ImPlotNative.ImPlot_ShowDemoWindow(p_open);
+        }
+        public static void ShowDemoWindow(ref bool p_open)
+        {
+            byte native_p_open_val = p_open ? (byte)1 : (byte)0;
+            byte* native_p_open = &native_p_open_val;
+            ImPlotNative.ImPlot_ShowDemoWindow(native_p_open);
+            p_open = native_p_open_val != 0;
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ShowInputMapSelector(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ShowInputMapSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ShowInputMapSelector(string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ShowInputMapSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+        public static void ShowMetricsWindow()
+        {
+            byte* p_popen = null;
+            ImPlotNative.ImPlot_ShowMetricsWindow(p_popen);
+        }
+        public static void ShowMetricsWindow(ref bool p_popen)
+        {
+            byte native_p_popen_val = p_popen ? (byte)1 : (byte)0;
+            byte* native_p_popen = &native_p_popen_val;
+            ImPlotNative.ImPlot_ShowMetricsWindow(native_p_popen);
+            p_popen = native_p_popen_val != 0;
+        }
+        public static void ShowStyleEditor()
+        {
+            ImPlotStyle* @ref = null;
+            ImPlotNative.ImPlot_ShowStyleEditor(@ref);
+        }
+        public static void ShowStyleEditor(ImPlotStylePtr @ref)
+        {
+            ImPlotStyle* native_ref = @ref.NativePtr;
+            ImPlotNative.ImPlot_ShowStyleEditor(native_ref);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static bool ShowStyleSelector(ReadOnlySpan<char> label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ShowStyleSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+#endif
+        public static bool ShowStyleSelector(string label)
+        {
+            byte* native_label;
+            int label_byteCount = 0;
+            if (label != null)
+            {
+                label_byteCount = Encoding.UTF8.GetByteCount(label);
+                if (label_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_label = Util.Allocate(label_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_label_stackBytes = stackalloc byte[label_byteCount + 1];
+                    native_label = native_label_stackBytes;
+                }
+                int native_label_offset = Util.GetUtf8(label, native_label, label_byteCount);
+                native_label[native_label_offset] = 0;
+            }
+            else { native_label = null; }
+            byte ret = ImPlotNative.ImPlot_ShowStyleSelector(native_label);
+            if (label_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_label);
+            }
+            return ret != 0;
+        }
+        public static void ShowUserGuide()
+        {
+            ImPlotNative.ImPlot_ShowUserGuide();
+        }
+        public static void StyleColorsAuto()
+        {
+            ImPlotStyle* dst = null;
+            ImPlotNative.ImPlot_StyleColorsAuto(dst);
+        }
+        public static void StyleColorsAuto(ImPlotStylePtr dst)
+        {
+            ImPlotStyle* native_dst = dst.NativePtr;
+            ImPlotNative.ImPlot_StyleColorsAuto(native_dst);
+        }
+        public static void StyleColorsClassic()
+        {
+            ImPlotStyle* dst = null;
+            ImPlotNative.ImPlot_StyleColorsClassic(dst);
+        }
+        public static void StyleColorsClassic(ImPlotStylePtr dst)
+        {
+            ImPlotStyle* native_dst = dst.NativePtr;
+            ImPlotNative.ImPlot_StyleColorsClassic(native_dst);
+        }
+        public static void StyleColorsDark()
+        {
+            ImPlotStyle* dst = null;
+            ImPlotNative.ImPlot_StyleColorsDark(dst);
+        }
+        public static void StyleColorsDark(ImPlotStylePtr dst)
+        {
+            ImPlotStyle* native_dst = dst.NativePtr;
+            ImPlotNative.ImPlot_StyleColorsDark(native_dst);
+        }
+        public static void StyleColorsLight()
+        {
+            ImPlotStyle* dst = null;
+            ImPlotNative.ImPlot_StyleColorsLight(dst);
+        }
+        public static void StyleColorsLight(ImPlotStylePtr dst)
+        {
+            ImPlotStyle* native_dst = dst.NativePtr;
+            ImPlotNative.ImPlot_StyleColorsLight(native_dst);
+        }
+        public static void TagX(double x, Vector4 col)
+        {
+            byte round = 0;
+            ImPlotNative.ImPlot_TagX_Bool(x, col, round);
+        }
+        public static void TagX(double x, Vector4 col, bool round)
+        {
+            byte native_round = round ? (byte)1 : (byte)0;
+            ImPlotNative.ImPlot_TagX_Bool(x, col, native_round);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TagX(double x, Vector4 col, ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_TagX_Str(x, col, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void TagX(double x, Vector4 col, string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_TagX_Str(x, col, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+        public static void TagY(double y, Vector4 col)
+        {
+            byte round = 0;
+            ImPlotNative.ImPlot_TagY_Bool(y, col, round);
+        }
+        public static void TagY(double y, Vector4 col, bool round)
+        {
+            byte native_round = round ? (byte)1 : (byte)0;
+            ImPlotNative.ImPlot_TagY_Bool(y, col, native_round);
+        }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1_OR_GREATER
+        public static void TagY(double y, Vector4 col, ReadOnlySpan<char> fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_TagY_Str(y, col, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+#endif
+        public static void TagY(double y, Vector4 col, string fmt)
+        {
+            byte* native_fmt;
+            int fmt_byteCount = 0;
+            if (fmt != null)
+            {
+                fmt_byteCount = Encoding.UTF8.GetByteCount(fmt);
+                if (fmt_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_fmt = Util.Allocate(fmt_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_fmt_stackBytes = stackalloc byte[fmt_byteCount + 1];
+                    native_fmt = native_fmt_stackBytes;
+                }
+                int native_fmt_offset = Util.GetUtf8(fmt, native_fmt, fmt_byteCount);
+                native_fmt[native_fmt_offset] = 0;
+            }
+            else { native_fmt = null; }
+            ImPlotNative.ImPlot_TagY_Str(y, col, native_fmt);
+            if (fmt_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_fmt);
+            }
+        }
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotAxisFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotAxisFlags.gen.cs
new file mode 100644
index 00000000..dce76f7c
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotAxisFlags.gen.cs
@@ -0,0 +1,27 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotAxisFlags
+    {
+        None = 0,
+        NoLabel = 1,
+        NoGridLines = 2,
+        NoTickMarks = 4,
+        NoTickLabels = 8,
+        NoInitialFit = 16,
+        NoMenus = 32,
+        NoSideSwitch = 64,
+        NoHighlight = 128,
+        Opposite = 256,
+        Foreground = 512,
+        Invert = 1024,
+        AutoFit = 2048,
+        RangeFit = 4096,
+        PanStretch = 8192,
+        LockMin = 16384,
+        LockMax = 32768,
+        Lock = 49152,
+        NoDecorations = 15,
+        AuxDefault = 258,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotBarGroupsFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotBarGroupsFlags.gen.cs
new file mode 100644
index 00000000..41612aaf
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotBarGroupsFlags.gen.cs
@@ -0,0 +1,10 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotBarGroupsFlags
+    {
+        None = 0,
+        Horizontal = 1024,
+        Stacked = 2048,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotBarsFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotBarsFlags.gen.cs
new file mode 100644
index 00000000..784948b1
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotBarsFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotBarsFlags
+    {
+        None = 0,
+        Horizontal = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotBin.gen.cs b/src/ImPlot.NET/Generated/ImPlotBin.gen.cs
new file mode 100644
index 00000000..935eeb5a
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotBin.gen.cs
@@ -0,0 +1,10 @@
+namespace ImPlotNET
+{
+    public enum ImPlotBin
+    {
+        Sqrt = -1,
+        Sturges = -2,
+        Rice = -3,
+        Scott = -4,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotCol.gen.cs b/src/ImPlot.NET/Generated/ImPlotCol.gen.cs
new file mode 100644
index 00000000..0e192d63
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotCol.gen.cs
@@ -0,0 +1,28 @@
+namespace ImPlotNET
+{
+    public enum ImPlotCol
+    {
+        Line = 0,
+        Fill = 1,
+        MarkerOutline = 2,
+        MarkerFill = 3,
+        ErrorBar = 4,
+        FrameBg = 5,
+        PlotBg = 6,
+        PlotBorder = 7,
+        LegendBg = 8,
+        LegendBorder = 9,
+        LegendText = 10,
+        TitleText = 11,
+        InlayText = 12,
+        AxisText = 13,
+        AxisGrid = 14,
+        AxisTick = 15,
+        AxisBg = 16,
+        AxisBgHovered = 17,
+        AxisBgActive = 18,
+        Selection = 19,
+        Crosshairs = 20,
+        COUNT = 21,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotColormap.gen.cs b/src/ImPlot.NET/Generated/ImPlotColormap.gen.cs
new file mode 100644
index 00000000..1e9c47d6
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotColormap.gen.cs
@@ -0,0 +1,22 @@
+namespace ImPlotNET
+{
+    public enum ImPlotColormap
+    {
+        Deep = 0,
+        Dark = 1,
+        Pastel = 2,
+        Paired = 3,
+        Viridis = 4,
+        Plasma = 5,
+        Hot = 6,
+        Cool = 7,
+        Pink = 8,
+        Jet = 9,
+        Twilight = 10,
+        RdBu = 11,
+        BrBG = 12,
+        PiYG = 13,
+        Spectral = 14,
+        Greys = 15,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotColormapScaleFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotColormapScaleFlags.gen.cs
new file mode 100644
index 00000000..68b3bb15
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotColormapScaleFlags.gen.cs
@@ -0,0 +1,11 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotColormapScaleFlags
+    {
+        None = 0,
+        NoLabel = 1,
+        Opposite = 2,
+        Invert = 4,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotCond.gen.cs b/src/ImPlot.NET/Generated/ImPlotCond.gen.cs
new file mode 100644
index 00000000..647df87a
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotCond.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    public enum ImPlotCond
+    {
+        None = 0,
+        Always = 1,
+        Once = 2,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotDigitalFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotDigitalFlags.gen.cs
new file mode 100644
index 00000000..778d1a50
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotDigitalFlags.gen.cs
@@ -0,0 +1,8 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotDigitalFlags
+    {
+        None = 0,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotDragToolFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotDragToolFlags.gen.cs
new file mode 100644
index 00000000..ebcd584d
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotDragToolFlags.gen.cs
@@ -0,0 +1,12 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotDragToolFlags
+    {
+        None = 0,
+        NoCursors = 1,
+        NoFit = 2,
+        NoInputs = 4,
+        Delayed = 8,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotDummyFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotDummyFlags.gen.cs
new file mode 100644
index 00000000..751b991c
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotDummyFlags.gen.cs
@@ -0,0 +1,8 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotDummyFlags
+    {
+        None = 0,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotErrorBarsFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotErrorBarsFlags.gen.cs
new file mode 100644
index 00000000..f81ee1b4
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotErrorBarsFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotErrorBarsFlags
+    {
+        None = 0,
+        Horizontal = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotFlags.gen.cs
new file mode 100644
index 00000000..5b28ac05
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotFlags.gen.cs
@@ -0,0 +1,19 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotFlags
+    {
+        None = 0,
+        NoTitle = 1,
+        NoLegend = 2,
+        NoMouseText = 4,
+        NoInputs = 8,
+        NoMenus = 16,
+        NoBoxSelect = 32,
+        NoChild = 64,
+        NoFrame = 128,
+        Equal = 256,
+        Crosshairs = 512,
+        CanvasOnly = 55,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotHeatmapFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotHeatmapFlags.gen.cs
new file mode 100644
index 00000000..88fba63b
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotHeatmapFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotHeatmapFlags
+    {
+        None = 0,
+        ColMajor = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotHistogramFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotHistogramFlags.gen.cs
new file mode 100644
index 00000000..b3c95513
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotHistogramFlags.gen.cs
@@ -0,0 +1,13 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotHistogramFlags
+    {
+        None = 0,
+        Horizontal = 1024,
+        Cumulative = 2048,
+        Density = 4096,
+        NoOutliers = 8192,
+        ColMajor = 16384,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotImageFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotImageFlags.gen.cs
new file mode 100644
index 00000000..bb26dd88
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotImageFlags.gen.cs
@@ -0,0 +1,8 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotImageFlags
+    {
+        None = 0,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotInfLinesFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotInfLinesFlags.gen.cs
new file mode 100644
index 00000000..1116a6dc
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotInfLinesFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotInfLinesFlags
+    {
+        None = 0,
+        Horizontal = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotInputMap.gen.cs b/src/ImPlot.NET/Generated/ImPlotInputMap.gen.cs
new file mode 100644
index 00000000..60024304
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotInputMap.gen.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public unsafe partial struct ImPlotInputMap
+    {
+        public ImGuiMouseButton Pan;
+        public ImGuiModFlags PanMod;
+        public ImGuiMouseButton Fit;
+        public ImGuiMouseButton Select;
+        public ImGuiMouseButton SelectCancel;
+        public ImGuiModFlags SelectMod;
+        public ImGuiModFlags SelectHorzMod;
+        public ImGuiModFlags SelectVertMod;
+        public ImGuiMouseButton Menu;
+        public ImGuiModFlags OverrideMod;
+        public ImGuiModFlags ZoomMod;
+        public float ZoomRate;
+    }
+    public unsafe partial struct ImPlotInputMapPtr
+    {
+        public ImPlotInputMap* NativePtr { get; }
+        public ImPlotInputMapPtr(ImPlotInputMap* nativePtr) => NativePtr = nativePtr;
+        public ImPlotInputMapPtr(IntPtr nativePtr) => NativePtr = (ImPlotInputMap*)nativePtr;
+        public static implicit operator ImPlotInputMapPtr(ImPlotInputMap* nativePtr) => new ImPlotInputMapPtr(nativePtr);
+        public static implicit operator ImPlotInputMap* (ImPlotInputMapPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotInputMapPtr(IntPtr nativePtr) => new ImPlotInputMapPtr(nativePtr);
+        public ref ImGuiMouseButton Pan => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->Pan);
+        public ref ImGuiModFlags PanMod => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->PanMod);
+        public ref ImGuiMouseButton Fit => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->Fit);
+        public ref ImGuiMouseButton Select => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->Select);
+        public ref ImGuiMouseButton SelectCancel => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->SelectCancel);
+        public ref ImGuiModFlags SelectMod => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->SelectMod);
+        public ref ImGuiModFlags SelectHorzMod => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->SelectHorzMod);
+        public ref ImGuiModFlags SelectVertMod => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->SelectVertMod);
+        public ref ImGuiMouseButton Menu => ref Unsafe.AsRef<ImGuiMouseButton>(&NativePtr->Menu);
+        public ref ImGuiModFlags OverrideMod => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->OverrideMod);
+        public ref ImGuiModFlags ZoomMod => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->ZoomMod);
+        public ref float ZoomRate => ref Unsafe.AsRef<float>(&NativePtr->ZoomRate);
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotInputMap_destroy((ImPlotInputMap*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotItemFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotItemFlags.gen.cs
new file mode 100644
index 00000000..b5c41986
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotItemFlags.gen.cs
@@ -0,0 +1,10 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotItemFlags
+    {
+        None = 0,
+        NoLegend = 1,
+        NoFit = 2,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotLegendFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotLegendFlags.gen.cs
new file mode 100644
index 00000000..4f6104e1
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotLegendFlags.gen.cs
@@ -0,0 +1,15 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotLegendFlags
+    {
+        None = 0,
+        NoButtons = 1,
+        NoHighlightItem = 2,
+        NoHighlightAxis = 4,
+        NoMenus = 8,
+        Outside = 16,
+        Horizontal = 32,
+        Sort = 64,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotLineFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotLineFlags.gen.cs
new file mode 100644
index 00000000..1983eaa2
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotLineFlags.gen.cs
@@ -0,0 +1,13 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotLineFlags
+    {
+        None = 0,
+        Segments = 1024,
+        Loop = 2048,
+        SkipNaN = 4096,
+        NoClip = 8192,
+        Shaded = 16384,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotLocation.gen.cs b/src/ImPlot.NET/Generated/ImPlotLocation.gen.cs
new file mode 100644
index 00000000..7e92e528
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotLocation.gen.cs
@@ -0,0 +1,15 @@
+namespace ImPlotNET
+{
+    public enum ImPlotLocation
+    {
+        Center = 0,
+        North = 1,
+        South = 2,
+        West = 4,
+        East = 8,
+        NorthWest = 5,
+        NorthEast = 9,
+        SouthWest = 6,
+        SouthEast = 10,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotMarker.gen.cs b/src/ImPlot.NET/Generated/ImPlotMarker.gen.cs
new file mode 100644
index 00000000..d8766e7a
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotMarker.gen.cs
@@ -0,0 +1,18 @@
+namespace ImPlotNET
+{
+    public enum ImPlotMarker
+    {
+        None = -1,
+        Circle = 0,
+        Square = 1,
+        Diamond = 2,
+        Up = 3,
+        Down = 4,
+        Left = 5,
+        Right = 6,
+        Cross = 7,
+        Plus = 8,
+        Asterisk = 9,
+        COUNT = 10,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotMouseTextFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotMouseTextFlags.gen.cs
new file mode 100644
index 00000000..03d76f65
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotMouseTextFlags.gen.cs
@@ -0,0 +1,11 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotMouseTextFlags
+    {
+        None = 0,
+        NoAuxAxes = 1,
+        NoFormat = 2,
+        ShowAlways = 4,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotNative.gen.cs b/src/ImPlot.NET/Generated/ImPlotNative.gen.cs
new file mode 100644
index 00000000..1f984b0d
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotNative.gen.cs
@@ -0,0 +1,759 @@
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public static unsafe partial class ImPlotNative
+    {
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotColormap ImPlot_AddColormap_Vec4Ptr(byte* name, Vector4* cols, int size, byte qual);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotColormap ImPlot_AddColormap_U32Ptr(byte* name, uint* cols, int size, byte qual);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_Annotation_Bool(double x, double y, Vector4 col, Vector2 pix_offset, byte clamp, byte round);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_Annotation_Str(double x, double y, Vector4 col, Vector2 pix_offset, byte clamp, byte* fmt);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginAlignedPlots(byte* group_id, byte vertical);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginDragDropSourceAxis(ImAxis axis, ImGuiDragDropFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginDragDropSourceItem(byte* label_id, ImGuiDragDropFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginDragDropSourcePlot(ImGuiDragDropFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginDragDropTargetAxis(ImAxis axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginDragDropTargetLegend();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginDragDropTargetPlot();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginLegendPopup(byte* label_id, ImGuiMouseButton mouse_button);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginPlot(byte* title_id, Vector2 size, ImPlotFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_BeginSubplots(byte* title_id, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* row_ratios, float* col_ratios);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_BustColorCache(byte* plot_title_id);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_CancelPlotSelection();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ColormapButton(byte* label, Vector2 size, ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ColormapIcon(ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ColormapScale(byte* label, double scale_min, double scale_max, Vector2 size, byte* format, ImPlotColormapScaleFlags flags, ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ColormapSlider(byte* label, float* t, Vector4* @out, byte* format, ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ImPlot_CreateContext();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_DestroyContext(IntPtr ctx);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragLineX(int id, double* x, Vector4 col, float thickness, ImPlotDragToolFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragLineY(int id, double* y, Vector4 col, float thickness, ImPlotDragToolFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragPoint(int id, double* x, double* y, Vector4 col, float size, ImPlotDragToolFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_DragRect(int id, double* x1, double* y1, double* x2, double* y2, Vector4 col, ImPlotDragToolFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndAlignedPlots();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndDragDropSource();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndDragDropTarget();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndLegendPopup();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndPlot();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_EndSubplots();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetColormapColor(Vector4* pOut, int idx, ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ImPlot_GetColormapCount();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotColormap ImPlot_GetColormapIndex(byte* name);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* ImPlot_GetColormapName(ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ImPlot_GetColormapSize(ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr ImPlot_GetCurrentContext();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotInputMap* ImPlot_GetInputMap();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetLastItemColor(Vector4* pOut);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* ImPlot_GetMarkerName(ImPlotMarker idx);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImDrawList* ImPlot_GetPlotDrawList();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRect ImPlot_GetPlotLimits(ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotMousePos(ImPlotPoint* pOut, ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotPos(Vector2* pOut);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRect ImPlot_GetPlotSelection(ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_GetPlotSize(Vector2* pOut);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotStyle* ImPlot_GetStyle();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte* ImPlot_GetStyleColorName(ImPlotCol idx);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_HideNextItem(byte hidden, ImPlotCond cond);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsAxisHovered(ImAxis axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsLegendEntryHovered(byte* label_id);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsPlotHovered();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsPlotSelected();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_IsSubplotsHovered();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ItemIcon_Vec4(Vector4 col);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ItemIcon_U32(uint col);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_MapInputDefault(ImPlotInputMap* dst);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_MapInputReverse(ImPlotInputMap* dst);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_NextColormapColor(Vector4* pOut);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PixelsToPlot_Vec2(ImPlotPoint* pOut, Vector2 pix, ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PixelsToPlot_Float(ImPlotPoint* pOut, float x, float y, ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_FloatPtr(byte** label_ids, float* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_doublePtr(byte** label_ids, double* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_S8Ptr(byte** label_ids, sbyte* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_U8Ptr(byte** label_ids, byte* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_S16Ptr(byte** label_ids, short* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_U16Ptr(byte** label_ids, ushort* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_S32Ptr(byte** label_ids, int* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_U32Ptr(byte** label_ids, uint* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_S64Ptr(byte** label_ids, long* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarGroups_U64Ptr(byte** label_ids, ulong* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_FloatPtrInt(byte* label_id, float* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_doublePtrInt(byte* label_id, double* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S8PtrInt(byte* label_id, sbyte* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U8PtrInt(byte* label_id, byte* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S16PtrInt(byte* label_id, short* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U16PtrInt(byte* label_id, ushort* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S32PtrInt(byte* label_id, int* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U32PtrInt(byte* label_id, uint* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S64PtrInt(byte* label_id, long* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U64PtrInt(byte* label_id, ulong* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_FloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_doublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_S64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBars_U64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotBarsG(byte* label_id, IntPtr getter, void* data, int count, double bar_size, ImPlotBarsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_FloatPtr(byte* label_id, float* xs, float* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_doublePtr(byte* label_id, double* xs, double* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_S8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_U8Ptr(byte* label_id, byte* xs, byte* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_S16Ptr(byte* label_id, short* xs, short* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_U16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_S32Ptr(byte* label_id, int* xs, int* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_U32Ptr(byte* label_id, uint* xs, uint* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_S64Ptr(byte* label_id, long* xs, long* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigital_U64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, ImPlotDigitalFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDigitalG(byte* label_id, IntPtr getter, void* data, int count, ImPlotDigitalFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotDummy(byte* label_id, ImPlotDummyFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(byte* label_id, float* xs, float* ys, float* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(byte* label_id, double* xs, double* ys, double* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(byte* label_id, sbyte* xs, sbyte* ys, sbyte* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(byte* label_id, byte* xs, byte* ys, byte* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(byte* label_id, short* xs, short* ys, short* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(byte* label_id, ushort* xs, ushort* ys, ushort* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(byte* label_id, int* xs, int* ys, int* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(byte* label_id, uint* xs, uint* ys, uint* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(byte* label_id, long* xs, long* ys, long* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(byte* label_id, ulong* xs, ulong* ys, ulong* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(byte* label_id, float* xs, float* ys, float* neg, float* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(byte* label_id, double* xs, double* ys, double* neg, double* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, sbyte* neg, sbyte* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, byte* neg, byte* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(byte* label_id, short* xs, short* ys, short* neg, short* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, ushort* neg, ushort* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(byte* label_id, int* xs, int* ys, int* neg, int* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, uint* neg, uint* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(byte* label_id, long* xs, long* ys, long* neg, long* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, ulong* neg, ulong* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_FloatPtr(byte* label_id, float* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_doublePtr(byte* label_id, double* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_S8Ptr(byte* label_id, sbyte* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_U8Ptr(byte* label_id, byte* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_S16Ptr(byte* label_id, short* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_U16Ptr(byte* label_id, ushort* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_S32Ptr(byte* label_id, int* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_U32Ptr(byte* label_id, uint* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_S64Ptr(byte* label_id, long* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotHeatmap_U64Ptr(byte* label_id, ulong* values, int rows, int cols, double scale_min, double scale_max, byte* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotHeatmapFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_FloatPtr(byte* label_id, float* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_doublePtr(byte* label_id, double* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_S8Ptr(byte* label_id, sbyte* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_U8Ptr(byte* label_id, byte* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_S16Ptr(byte* label_id, short* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_U16Ptr(byte* label_id, ushort* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_S32Ptr(byte* label_id, int* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_U32Ptr(byte* label_id, uint* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_S64Ptr(byte* label_id, long* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram_U64Ptr(byte* label_id, ulong* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_FloatPtr(byte* label_id, float* xs, float* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_doublePtr(byte* label_id, double* xs, double* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_S8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_U8Ptr(byte* label_id, byte* xs, byte* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_S16Ptr(byte* label_id, short* xs, short* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_U16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_S32Ptr(byte* label_id, int* xs, int* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_U32Ptr(byte* label_id, uint* xs, uint* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_S64Ptr(byte* label_id, long* xs, long* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlot_PlotHistogram2D_U64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotHistogramFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotImage(byte* label_id, IntPtr user_texture_id, ImPlotPoint bounds_min, ImPlotPoint bounds_max, Vector2 uv0, Vector2 uv1, Vector4 tint_col, ImPlotImageFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_FloatPtr(byte* label_id, float* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_doublePtr(byte* label_id, double* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_S8Ptr(byte* label_id, sbyte* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_U8Ptr(byte* label_id, byte* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_S16Ptr(byte* label_id, short* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_U16Ptr(byte* label_id, ushort* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_S32Ptr(byte* label_id, int* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_U32Ptr(byte* label_id, uint* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_S64Ptr(byte* label_id, long* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotInfLines_U64Ptr(byte* label_id, ulong* values, int count, ImPlotInfLinesFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_FloatPtrInt(byte* label_id, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_doublePtrInt(byte* label_id, double* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S8PtrInt(byte* label_id, sbyte* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U8PtrInt(byte* label_id, byte* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S16PtrInt(byte* label_id, short* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U16PtrInt(byte* label_id, ushort* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S32PtrInt(byte* label_id, int* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U32PtrInt(byte* label_id, uint* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S64PtrInt(byte* label_id, long* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U64PtrInt(byte* label_id, ulong* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_FloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_doublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_S64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLine_U64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, ImPlotLineFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotLineG(byte* label_id, IntPtr getter, void* data, int count, ImPlotLineFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_FloatPtr(byte** label_ids, float* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_doublePtr(byte** label_ids, double* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_S8Ptr(byte** label_ids, sbyte* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_U8Ptr(byte** label_ids, byte* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_S16Ptr(byte** label_ids, short* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_U16Ptr(byte** label_ids, ushort* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_S32Ptr(byte** label_ids, int* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_U32Ptr(byte** label_ids, uint* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_S64Ptr(byte** label_ids, long* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotPieChart_U64Ptr(byte** label_ids, ulong* values, int count, double x, double y, double radius, byte* label_fmt, double angle0, ImPlotPieChartFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_FloatPtrInt(byte* label_id, float* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_doublePtrInt(byte* label_id, double* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S8PtrInt(byte* label_id, sbyte* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U8PtrInt(byte* label_id, byte* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S16PtrInt(byte* label_id, short* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U16PtrInt(byte* label_id, ushort* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S32PtrInt(byte* label_id, int* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U32PtrInt(byte* label_id, uint* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S64PtrInt(byte* label_id, long* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U64PtrInt(byte* label_id, ulong* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_FloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_doublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_S64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatter_U64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, ImPlotScatterFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotScatterG(byte* label_id, IntPtr getter, void* data, int count, ImPlotScatterFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_FloatPtrInt(byte* label_id, float* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_doublePtrInt(byte* label_id, double* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S8PtrInt(byte* label_id, sbyte* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U8PtrInt(byte* label_id, byte* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S16PtrInt(byte* label_id, short* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U16PtrInt(byte* label_id, ushort* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S32PtrInt(byte* label_id, int* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U32PtrInt(byte* label_id, uint* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S64PtrInt(byte* label_id, long* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U64PtrInt(byte* label_id, ulong* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_FloatPtrFloatPtrInt(byte* label_id, float* xs, float* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_doublePtrdoublePtrInt(byte* label_id, double* xs, double* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S8PtrS8PtrInt(byte* label_id, sbyte* xs, sbyte* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U8PtrU8PtrInt(byte* label_id, byte* xs, byte* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S16PtrS16PtrInt(byte* label_id, short* xs, short* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U16PtrU16PtrInt(byte* label_id, ushort* xs, ushort* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S32PtrS32PtrInt(byte* label_id, int* xs, int* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U32PtrU32PtrInt(byte* label_id, uint* xs, uint* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S64PtrS64PtrInt(byte* label_id, long* xs, long* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U64PtrU64PtrInt(byte* label_id, ulong* xs, ulong* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(byte* label_id, float* xs, float* ys1, float* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(byte* label_id, double* xs, double* ys1, double* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys1, sbyte* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(byte* label_id, byte* xs, byte* ys1, byte* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(byte* label_id, short* xs, short* ys1, short* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys1, ushort* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(byte* label_id, int* xs, int* ys1, int* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(byte* label_id, uint* xs, uint* ys1, uint* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(byte* label_id, long* xs, long* ys1, long* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys1, ulong* ys2, int count, ImPlotShadedFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotShadedG(byte* label_id, IntPtr getter1, void* data1, IntPtr getter2, void* data2, int count, ImPlotShadedFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_FloatPtrInt(byte* label_id, float* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_doublePtrInt(byte* label_id, double* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S8PtrInt(byte* label_id, sbyte* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U8PtrInt(byte* label_id, byte* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S16PtrInt(byte* label_id, short* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U16PtrInt(byte* label_id, ushort* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S32PtrInt(byte* label_id, int* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U32PtrInt(byte* label_id, uint* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S64PtrInt(byte* label_id, long* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U64PtrInt(byte* label_id, ulong* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_FloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_doublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_S64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairs_U64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, ImPlotStairsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStairsG(byte* label_id, IntPtr getter, void* data, int count, ImPlotStairsFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_FloatPtrInt(byte* label_id, float* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_doublePtrInt(byte* label_id, double* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S8PtrInt(byte* label_id, sbyte* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U8PtrInt(byte* label_id, byte* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S16PtrInt(byte* label_id, short* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U16PtrInt(byte* label_id, ushort* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S32PtrInt(byte* label_id, int* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U32PtrInt(byte* label_id, uint* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S64PtrInt(byte* label_id, long* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U64PtrInt(byte* label_id, ulong* values, int count, double @ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_FloatPtrFloatPtr(byte* label_id, float* xs, float* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_doublePtrdoublePtr(byte* label_id, double* xs, double* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S8PtrS8Ptr(byte* label_id, sbyte* xs, sbyte* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U8PtrU8Ptr(byte* label_id, byte* xs, byte* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S16PtrS16Ptr(byte* label_id, short* xs, short* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U16PtrU16Ptr(byte* label_id, ushort* xs, ushort* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S32PtrS32Ptr(byte* label_id, int* xs, int* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U32PtrU32Ptr(byte* label_id, uint* xs, uint* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_S64PtrS64Ptr(byte* label_id, long* xs, long* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotStems_U64PtrU64Ptr(byte* label_id, ulong* xs, ulong* ys, int count, double @ref, ImPlotStemsFlags flags, int offset, int stride);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotText(byte* text, double x, double y, Vector2 pix_offset, ImPlotTextFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotToPixels_PlotPoInt(Vector2* pOut, ImPlotPoint plt, ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PlotToPixels_double(Vector2* pOut, double x, double y, ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopColormap(int count);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopPlotClipRect();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopStyleColor(int count);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PopStyleVar(int count);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushColormap_PlotColormap(ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushColormap_Str(byte* name);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushPlotClipRect(float expand);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleColor_U32(ImPlotCol idx, uint col);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleColor_Vec4(ImPlotCol idx, Vector4 col);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleVar_Float(ImPlotStyleVar idx, float val);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleVar_Int(ImPlotStyleVar idx, int val);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_PushStyleVar_Vec2(ImPlotStyleVar idx, Vector2 val);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SampleColormap(Vector4* pOut, float t, ImPlotColormap cmap);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetAxes(ImAxis x_axis, ImAxis y_axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetAxis(ImAxis axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetCurrentContext(IntPtr ctx);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetImGuiContext(IntPtr ctx);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextAxesToFit();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextAxisLinks(ImAxis axis, double* link_min, double* link_max);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextAxisToFit(ImAxis axis);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextErrorBarStyle(Vector4 col, float size, float weight);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextFillStyle(Vector4 col, float alpha_mod);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextLineStyle(Vector4 col, float weight);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetNextMarkerStyle(ImPlotMarker marker, float size, Vector4 fill, float weight, Vector4 outline);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxes(byte* x_label, byte* y_label, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxis(ImAxis axis, byte* label, ImPlotAxisFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisFormat_Str(ImAxis axis, byte* fmt);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisFormat_PlotFormatter(ImAxis axis, IntPtr formatter, void* data);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisLimitsConstraints(ImAxis axis, double v_min, double v_max);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisLinks(ImAxis axis, double* link_min, double* link_max);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisScale_PlotScale(ImAxis axis, ImPlotScale scale);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisScale_PlotTransform(ImAxis axis, IntPtr forward, IntPtr inverse, void* data);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisTicks_doublePtr(ImAxis axis, double* values, int n_ticks, byte** labels, byte keep_default);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisTicks_double(ImAxis axis, double v_min, double v_max, int n_ticks, byte** labels, byte keep_default);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupAxisZoomConstraints(ImAxis axis, double z_min, double z_max);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupFinish();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ShowColormapSelector(byte* label);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowDemoWindow(byte* p_open);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ShowInputMapSelector(byte* label);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowMetricsWindow(byte* p_popen);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowStyleEditor(ImPlotStyle* @ref);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlot_ShowStyleSelector(byte* label);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_ShowUserGuide();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsAuto(ImPlotStyle* dst);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsClassic(ImPlotStyle* dst);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsDark(ImPlotStyle* dst);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_StyleColorsLight(ImPlotStyle* dst);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_TagX_Bool(double x, Vector4 col, byte round);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_TagX_Str(double x, Vector4 col, byte* fmt);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_TagY_Bool(double y, Vector4 col, byte round);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlot_TagY_Str(double y, Vector4 col, byte* fmt);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotInputMap_destroy(ImPlotInputMap* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotInputMap* ImPlotInputMap_ImPlotInputMap();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotPoint_destroy(ImPlotPoint* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotPoint* ImPlotPoint_ImPlotPoint_Nil();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotPoint* ImPlotPoint_ImPlotPoint_double(double _x, double _y);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotPoint* ImPlotPoint_ImPlotPoint_Vec2(Vector2 p);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlotRange_Clamp(ImPlotRange* self, double value);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlotRange_Contains(ImPlotRange* self, double value);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRange_destroy(ImPlotRange* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRange* ImPlotRange_ImPlotRange_Nil();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRange* ImPlotRange_ImPlotRange_double(double _min, double _max);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern double ImPlotRange_Size(ImPlotRange* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRect_Clamp_PlotPoInt(ImPlotPoint* pOut, ImPlotRect* self, ImPlotPoint p);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRect_Clamp_double(ImPlotPoint* pOut, ImPlotRect* self, double x, double y);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlotRect_Contains_PlotPoInt(ImPlotRect* self, ImPlotPoint p);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern byte ImPlotRect_Contains_double(ImPlotRect* self, double x, double y);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRect_destroy(ImPlotRect* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRect* ImPlotRect_ImPlotRect_Nil();
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotRect* ImPlotRect_ImPlotRect_double(double x_min, double x_max, double y_min, double y_max);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRect_Max(ImPlotPoint* pOut, ImPlotRect* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRect_Min(ImPlotPoint* pOut, ImPlotRect* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotRect_Size(ImPlotPoint* pOut, ImPlotRect* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ImPlotStyle_destroy(ImPlotStyle* self);
+        [DllImport("cimplot", CallingConvention = CallingConvention.Cdecl)]
+        public static extern ImPlotStyle* ImPlotStyle_ImPlotStyle();
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotPieChartFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotPieChartFlags.gen.cs
new file mode 100644
index 00000000..f0da3df7
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotPieChartFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotPieChartFlags
+    {
+        None = 0,
+        Normalize = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotPoint.gen.cs b/src/ImPlot.NET/Generated/ImPlotPoint.gen.cs
new file mode 100644
index 00000000..f766cb22
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotPoint.gen.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public unsafe partial struct ImPlotPoint
+    {
+        public double x;
+        public double y;
+    }
+    public unsafe partial struct ImPlotPointPtr
+    {
+        public ImPlotPoint* NativePtr { get; }
+        public ImPlotPointPtr(ImPlotPoint* nativePtr) => NativePtr = nativePtr;
+        public ImPlotPointPtr(IntPtr nativePtr) => NativePtr = (ImPlotPoint*)nativePtr;
+        public static implicit operator ImPlotPointPtr(ImPlotPoint* nativePtr) => new ImPlotPointPtr(nativePtr);
+        public static implicit operator ImPlotPoint* (ImPlotPointPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotPointPtr(IntPtr nativePtr) => new ImPlotPointPtr(nativePtr);
+        public ref double x => ref Unsafe.AsRef<double>(&NativePtr->x);
+        public ref double y => ref Unsafe.AsRef<double>(&NativePtr->y);
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotPoint_destroy((ImPlotPoint*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotRange.gen.cs b/src/ImPlot.NET/Generated/ImPlotRange.gen.cs
new file mode 100644
index 00000000..8a1f6061
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotRange.gen.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public unsafe partial struct ImPlotRange
+    {
+        public double Min;
+        public double Max;
+    }
+    public unsafe partial struct ImPlotRangePtr
+    {
+        public ImPlotRange* NativePtr { get; }
+        public ImPlotRangePtr(ImPlotRange* nativePtr) => NativePtr = nativePtr;
+        public ImPlotRangePtr(IntPtr nativePtr) => NativePtr = (ImPlotRange*)nativePtr;
+        public static implicit operator ImPlotRangePtr(ImPlotRange* nativePtr) => new ImPlotRangePtr(nativePtr);
+        public static implicit operator ImPlotRange* (ImPlotRangePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotRangePtr(IntPtr nativePtr) => new ImPlotRangePtr(nativePtr);
+        public ref double Min => ref Unsafe.AsRef<double>(&NativePtr->Min);
+        public ref double Max => ref Unsafe.AsRef<double>(&NativePtr->Max);
+        public double Clamp(double value)
+        {
+            double ret = ImPlotNative.ImPlotRange_Clamp((ImPlotRange*)(NativePtr), value);
+            return ret;
+        }
+        public bool Contains(double value)
+        {
+            byte ret = ImPlotNative.ImPlotRange_Contains((ImPlotRange*)(NativePtr), value);
+            return ret != 0;
+        }
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotRange_destroy((ImPlotRange*)(NativePtr));
+        }
+        public double Size()
+        {
+            double ret = ImPlotNative.ImPlotRange_Size((ImPlotRange*)(NativePtr));
+            return ret;
+        }
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotRect.gen.cs b/src/ImPlot.NET/Generated/ImPlotRect.gen.cs
new file mode 100644
index 00000000..61ff0aea
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotRect.gen.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public unsafe partial struct ImPlotRect
+    {
+        public ImPlotRange X;
+        public ImPlotRange Y;
+    }
+    public unsafe partial struct ImPlotRectPtr
+    {
+        public ImPlotRect* NativePtr { get; }
+        public ImPlotRectPtr(ImPlotRect* nativePtr) => NativePtr = nativePtr;
+        public ImPlotRectPtr(IntPtr nativePtr) => NativePtr = (ImPlotRect*)nativePtr;
+        public static implicit operator ImPlotRectPtr(ImPlotRect* nativePtr) => new ImPlotRectPtr(nativePtr);
+        public static implicit operator ImPlotRect* (ImPlotRectPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotRectPtr(IntPtr nativePtr) => new ImPlotRectPtr(nativePtr);
+        public ref ImPlotRange X => ref Unsafe.AsRef<ImPlotRange>(&NativePtr->X);
+        public ref ImPlotRange Y => ref Unsafe.AsRef<ImPlotRange>(&NativePtr->Y);
+        public ImPlotPoint Clamp(ImPlotPoint p)
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlotRect_Clamp_PlotPoInt(&__retval, (ImPlotRect*)(NativePtr), p);
+            return __retval;
+        }
+        public ImPlotPoint Clamp(double x, double y)
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlotRect_Clamp_double(&__retval, (ImPlotRect*)(NativePtr), x, y);
+            return __retval;
+        }
+        public bool Contains(ImPlotPoint p)
+        {
+            byte ret = ImPlotNative.ImPlotRect_Contains_PlotPoInt((ImPlotRect*)(NativePtr), p);
+            return ret != 0;
+        }
+        public bool Contains(double x, double y)
+        {
+            byte ret = ImPlotNative.ImPlotRect_Contains_double((ImPlotRect*)(NativePtr), x, y);
+            return ret != 0;
+        }
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotRect_destroy((ImPlotRect*)(NativePtr));
+        }
+        public ImPlotPoint Max()
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlotRect_Max(&__retval, (ImPlotRect*)(NativePtr));
+            return __retval;
+        }
+        public ImPlotPoint Min()
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlotRect_Min(&__retval, (ImPlotRect*)(NativePtr));
+            return __retval;
+        }
+        public ImPlotPoint Size()
+        {
+            ImPlotPoint __retval;
+            ImPlotNative.ImPlotRect_Size(&__retval, (ImPlotRect*)(NativePtr));
+            return __retval;
+        }
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotScale.gen.cs b/src/ImPlot.NET/Generated/ImPlotScale.gen.cs
new file mode 100644
index 00000000..dc837dc8
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotScale.gen.cs
@@ -0,0 +1,10 @@
+namespace ImPlotNET
+{
+    public enum ImPlotScale
+    {
+        Linear = 0,
+        Time = 1,
+        Log10 = 2,
+        SymLog = 3,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotScatterFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotScatterFlags.gen.cs
new file mode 100644
index 00000000..46b11c67
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotScatterFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotScatterFlags
+    {
+        None = 0,
+        NoClip = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotShadedFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotShadedFlags.gen.cs
new file mode 100644
index 00000000..1d1acc38
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotShadedFlags.gen.cs
@@ -0,0 +1,8 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotShadedFlags
+    {
+        None = 0,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotStairsFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotStairsFlags.gen.cs
new file mode 100644
index 00000000..73f7b922
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotStairsFlags.gen.cs
@@ -0,0 +1,10 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotStairsFlags
+    {
+        None = 0,
+        PreStep = 1024,
+        Shaded = 2048,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotStemsFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotStemsFlags.gen.cs
new file mode 100644
index 00000000..8ef98b9e
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotStemsFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotStemsFlags
+    {
+        None = 0,
+        Horizontal = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotStyle.gen.cs b/src/ImPlot.NET/Generated/ImPlotStyle.gen.cs
new file mode 100644
index 00000000..cf31109b
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotStyle.gen.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImGuiNET;
+
+namespace ImPlotNET
+{
+    public unsafe partial struct ImPlotStyle
+    {
+        public float LineWeight;
+        public int Marker;
+        public float MarkerSize;
+        public float MarkerWeight;
+        public float FillAlpha;
+        public float ErrorBarSize;
+        public float ErrorBarWeight;
+        public float DigitalBitHeight;
+        public float DigitalBitGap;
+        public float PlotBorderSize;
+        public float MinorAlpha;
+        public Vector2 MajorTickLen;
+        public Vector2 MinorTickLen;
+        public Vector2 MajorTickSize;
+        public Vector2 MinorTickSize;
+        public Vector2 MajorGridSize;
+        public Vector2 MinorGridSize;
+        public Vector2 PlotPadding;
+        public Vector2 LabelPadding;
+        public Vector2 LegendPadding;
+        public Vector2 LegendInnerPadding;
+        public Vector2 LegendSpacing;
+        public Vector2 MousePosPadding;
+        public Vector2 AnnotationPadding;
+        public Vector2 FitPadding;
+        public Vector2 PlotDefaultSize;
+        public Vector2 PlotMinSize;
+        public Vector4 Colors_0;
+        public Vector4 Colors_1;
+        public Vector4 Colors_2;
+        public Vector4 Colors_3;
+        public Vector4 Colors_4;
+        public Vector4 Colors_5;
+        public Vector4 Colors_6;
+        public Vector4 Colors_7;
+        public Vector4 Colors_8;
+        public Vector4 Colors_9;
+        public Vector4 Colors_10;
+        public Vector4 Colors_11;
+        public Vector4 Colors_12;
+        public Vector4 Colors_13;
+        public Vector4 Colors_14;
+        public Vector4 Colors_15;
+        public Vector4 Colors_16;
+        public Vector4 Colors_17;
+        public Vector4 Colors_18;
+        public Vector4 Colors_19;
+        public Vector4 Colors_20;
+        public ImPlotColormap Colormap;
+        public byte UseLocalTime;
+        public byte UseISO8601;
+        public byte Use24HourClock;
+    }
+    public unsafe partial struct ImPlotStylePtr
+    {
+        public ImPlotStyle* NativePtr { get; }
+        public ImPlotStylePtr(ImPlotStyle* nativePtr) => NativePtr = nativePtr;
+        public ImPlotStylePtr(IntPtr nativePtr) => NativePtr = (ImPlotStyle*)nativePtr;
+        public static implicit operator ImPlotStylePtr(ImPlotStyle* nativePtr) => new ImPlotStylePtr(nativePtr);
+        public static implicit operator ImPlotStyle* (ImPlotStylePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImPlotStylePtr(IntPtr nativePtr) => new ImPlotStylePtr(nativePtr);
+        public ref float LineWeight => ref Unsafe.AsRef<float>(&NativePtr->LineWeight);
+        public ref int Marker => ref Unsafe.AsRef<int>(&NativePtr->Marker);
+        public ref float MarkerSize => ref Unsafe.AsRef<float>(&NativePtr->MarkerSize);
+        public ref float MarkerWeight => ref Unsafe.AsRef<float>(&NativePtr->MarkerWeight);
+        public ref float FillAlpha => ref Unsafe.AsRef<float>(&NativePtr->FillAlpha);
+        public ref float ErrorBarSize => ref Unsafe.AsRef<float>(&NativePtr->ErrorBarSize);
+        public ref float ErrorBarWeight => ref Unsafe.AsRef<float>(&NativePtr->ErrorBarWeight);
+        public ref float DigitalBitHeight => ref Unsafe.AsRef<float>(&NativePtr->DigitalBitHeight);
+        public ref float DigitalBitGap => ref Unsafe.AsRef<float>(&NativePtr->DigitalBitGap);
+        public ref float PlotBorderSize => ref Unsafe.AsRef<float>(&NativePtr->PlotBorderSize);
+        public ref float MinorAlpha => ref Unsafe.AsRef<float>(&NativePtr->MinorAlpha);
+        public ref Vector2 MajorTickLen => ref Unsafe.AsRef<Vector2>(&NativePtr->MajorTickLen);
+        public ref Vector2 MinorTickLen => ref Unsafe.AsRef<Vector2>(&NativePtr->MinorTickLen);
+        public ref Vector2 MajorTickSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MajorTickSize);
+        public ref Vector2 MinorTickSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MinorTickSize);
+        public ref Vector2 MajorGridSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MajorGridSize);
+        public ref Vector2 MinorGridSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MinorGridSize);
+        public ref Vector2 PlotPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->PlotPadding);
+        public ref Vector2 LabelPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->LabelPadding);
+        public ref Vector2 LegendPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->LegendPadding);
+        public ref Vector2 LegendInnerPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->LegendInnerPadding);
+        public ref Vector2 LegendSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->LegendSpacing);
+        public ref Vector2 MousePosPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePosPadding);
+        public ref Vector2 AnnotationPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->AnnotationPadding);
+        public ref Vector2 FitPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->FitPadding);
+        public ref Vector2 PlotDefaultSize => ref Unsafe.AsRef<Vector2>(&NativePtr->PlotDefaultSize);
+        public ref Vector2 PlotMinSize => ref Unsafe.AsRef<Vector2>(&NativePtr->PlotMinSize);
+        public RangeAccessor<Vector4> Colors => new RangeAccessor<Vector4>(&NativePtr->Colors_0, 21);
+        public ref ImPlotColormap Colormap => ref Unsafe.AsRef<ImPlotColormap>(&NativePtr->Colormap);
+        public ref bool UseLocalTime => ref Unsafe.AsRef<bool>(&NativePtr->UseLocalTime);
+        public ref bool UseISO8601 => ref Unsafe.AsRef<bool>(&NativePtr->UseISO8601);
+        public ref bool Use24HourClock => ref Unsafe.AsRef<bool>(&NativePtr->Use24HourClock);
+        public void Destroy()
+        {
+            ImPlotNative.ImPlotStyle_destroy((ImPlotStyle*)(NativePtr));
+        }
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotStyleVar.gen.cs b/src/ImPlot.NET/Generated/ImPlotStyleVar.gen.cs
new file mode 100644
index 00000000..5be78c63
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotStyleVar.gen.cs
@@ -0,0 +1,34 @@
+namespace ImPlotNET
+{
+    public enum ImPlotStyleVar
+    {
+        LineWeight = 0,
+        Marker = 1,
+        MarkerSize = 2,
+        MarkerWeight = 3,
+        FillAlpha = 4,
+        ErrorBarSize = 5,
+        ErrorBarWeight = 6,
+        DigitalBitHeight = 7,
+        DigitalBitGap = 8,
+        PlotBorderSize = 9,
+        MinorAlpha = 10,
+        MajorTickLen = 11,
+        MinorTickLen = 12,
+        MajorTickSize = 13,
+        MinorTickSize = 14,
+        MajorGridSize = 15,
+        MinorGridSize = 16,
+        PlotPadding = 17,
+        LabelPadding = 18,
+        LegendPadding = 19,
+        LegendInnerPadding = 20,
+        LegendSpacing = 21,
+        MousePosPadding = 22,
+        AnnotationPadding = 23,
+        FitPadding = 24,
+        PlotDefaultSize = 25,
+        PlotMinSize = 26,
+        COUNT = 27,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotSubplotFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotSubplotFlags.gen.cs
new file mode 100644
index 00000000..a36ece71
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotSubplotFlags.gen.cs
@@ -0,0 +1,19 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotSubplotFlags
+    {
+        None = 0,
+        NoTitle = 1,
+        NoLegend = 2,
+        NoMenus = 4,
+        NoResize = 8,
+        NoAlign = 16,
+        ShareItems = 32,
+        LinkRows = 64,
+        LinkCols = 128,
+        LinkAllX = 256,
+        LinkAllY = 512,
+        ColMajor = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/Generated/ImPlotTextFlags.gen.cs b/src/ImPlot.NET/Generated/ImPlotTextFlags.gen.cs
new file mode 100644
index 00000000..df23e4d4
--- /dev/null
+++ b/src/ImPlot.NET/Generated/ImPlotTextFlags.gen.cs
@@ -0,0 +1,9 @@
+namespace ImPlotNET
+{
+    [System.Flags]
+    public enum ImPlotTextFlags
+    {
+        None = 0,
+        Vertical = 1024,
+    }
+}
diff --git a/src/ImPlot.NET/ImPlot.NET.csproj b/src/ImPlot.NET/ImPlot.NET.csproj
new file mode 100644
index 00000000..4722ad70
--- /dev/null
+++ b/src/ImPlot.NET/ImPlot.NET.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <Description>A .NET wrapper for the ImPlot library.</Description>
+    <AssemblyVersion>0.8.0</AssemblyVersion>
+    <Authors>Eric Mellino</Authors>
+    <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>portable</DebugType>
+    <AssemblyName>ImPlot.NET</AssemblyName>
+    <PackageId>ImPlot.NET</PackageId>
+    <PackagePrereleaseIdentifier></PackagePrereleaseIdentifier>
+    <PackageVersion>$(AssemblyVersion)$(PackagePrereleaseIdentifier)</PackageVersion>
+    <PackageTags>ImPlot ImGui ImGui.NET Immediate Mode GUI</PackageTags>
+    <PackageProjectUrl>https://github.com/mellinoe/imgui.net</PackageProjectUrl>
+    <DocumentationFile Condition="'$(Configuration)' == 'Release'">$(OutputPath)\ImPlot.NET.xml</DocumentationFile>
+    <RootNamespace>ImPlotNET</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <PackageReference Include="System.Buffers" Version="4.5.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ImGui.NET\ImGui.NET.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="build\net40" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Remove="build\net40\ImPlot.NET.targets" />
+  </ItemGroup>
+</Project>
diff --git a/src/TestDotNetStandardLib/TestDotNetStandardLib.csproj b/src/TestDotNetStandardLib/TestDotNetStandardLib.csproj
new file mode 100644
index 00000000..ec271880
--- /dev/null
+++ b/src/TestDotNetStandardLib/TestDotNetStandardLib.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\ImGui.NET\ImGui.NET.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/src/TestDotNetStandardLib/TestStringParameterOnDotNetStandard.cs b/src/TestDotNetStandardLib/TestStringParameterOnDotNetStandard.cs
new file mode 100644
index 00000000..5d7d8a22
--- /dev/null
+++ b/src/TestDotNetStandardLib/TestStringParameterOnDotNetStandard.cs
@@ -0,0 +1,14 @@
+using ImGuiNET;
+
+namespace TestDotNetStandardLib
+{
+	public static class TestStringParameterOnDotNetStandard
+	{
+		public static void Text()
+		{
+			ImGui.Text(".NET Standard 2.0 test!");
+			ImGui.GetWindowDrawList().AddText(ImGui.GetCursorScreenPos(), uint.MaxValue, "DrawList works on .NET Standard too");
+			ImGui.NewLine();
+		}
+	}
+}